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

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

@@ -0,0 +1,237 @@
+import { each, remove, uniq } from 'lodash';
+import { Observable } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { StringifyingMap } from '../../../core';
+export class RemoteVariableCommunicator {
+    constructor(remoteVariableProtocol, logger) {
+        this.remoteVariableProtocol = remoteVariableProtocol;
+        this.logger = logger;
+        this.observers = new Map();
+        this.appIdVariablesMap = new Map();
+        this.variableStateObservers = new Map();
+        this.variableStateCache = new Map();
+        this.alarmObservers = [];
+        this.variableValueCache = new StringifyingMap(k => JSON.stringify(k));
+        this.connectedSubscription = this.remoteVariableProtocol.connected.subscribe(() => {
+            const variableNamesToStart = [];
+            this.variableStateObservers.forEach((__, variableName) => {
+                variableNamesToStart.push(variableName);
+            });
+            this.remoteVariableProtocol.subscribeVariableStates(variableNamesToStart);
+            this.appIdVariablesMap.forEach((variableNames, appId) => {
+                this.remoteVariableProtocol.tryOpenVariables(variableNames, appId);
+            });
+        });
+        this.doVariableStatesChanged();
+        this.doVariableValuesChanged();
+        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) {
+            this.variableValuesChangedSubscription.unsubscribe();
+        }
+        this.variableValuesChangedSubscription =
+            this.remoteVariableProtocol.variableValuesChanged.subscribe((values) => {
+                each(values, variableValue => {
+                    const variableName = variableValue.variableName;
+                    this.variableValueCache.set(variableName, variableValue);
+                    if (this.observers.has(variableName)) {
+                        each(this.observers.get(variableName), ob => {
+                            // TODO 同一个ob监听多个变量的情况，组合成数组一次推送。
+                            ob.next([variableValue]);
+                        });
+                    }
+                });
+            });
+    }
+    doVariableStatesChanged() {
+        if (this.variableStatesChangedSubscription !== undefined) {
+            this.variableStatesChangedSubscription.unsubscribe();
+        }
+        this.variableStatesChangedSubscription =
+            this.remoteVariableProtocol.variableStatesChanged.subscribe((states) => {
+                each(states, state => {
+                    const variableName = state.variableName;
+                    this.variableStateCache.set(variableName, state);
+                    if (this.variableStateObservers.has(variableName)) {
+                        each(this.variableStateObservers.get(variableName), ob => {
+                            // TODO 同一个ob监听多个变量的情况，组合成数组一次推送。
+                            ob.next([state]);
+                        });
+                    }
+                });
+            });
+    }
+    subscribeVariableStates(variableNames) {
+        return new Observable(observer => {
+            let variableNamesToStart = [];
+            each(variableNames, variableName => {
+                if (!this.variableStateObservers.has(variableName)) {
+                    this.variableStateObservers.set(variableName, []);
+                    variableNamesToStart.push(variableName);
+                }
+                else {
+                    if (this.variableStateCache.has(variableName)) {
+                        observer.next([this.variableStateCache.get(variableName)]);
+                    }
+                }
+                this.variableStateObservers.get(variableName).push(observer);
+            });
+            variableNamesToStart = uniq(variableNamesToStart);
+            if (variableNamesToStart && variableNamesToStart.length > 0) {
+                if (!this.variableStatesToBeOpened) {
+                    this.variableStatesToBeOpened = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.subscribeVariableStates(this.variableStatesToBeOpened);
+                        delete this.variableStatesToBeOpened;
+                    });
+                }
+                this.variableStatesToBeOpened.push(...variableNamesToStart);
+            }
+            return () => {
+                const stopedVariableStates = [];
+                each(variableNames, variableName => {
+                    const obs = this.variableStateObservers.get(variableName);
+                    if (obs) {
+                        remove(obs, item => item === observer);
+                        if (obs.length <= 0) {
+                            this.variableStateObservers.delete(variableName);
+                            stopedVariableStates.push(variableName);
+                        }
+                    }
+                });
+                if (!stopedVariableStates.length) {
+                    return;
+                }
+                if (!this.variableStatesToBeClosed) {
+                    this.variableStatesToBeClosed = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.unsubscribeVariableStates(this.variableStatesToBeClosed);
+                        delete this.variableStatesToBeClosed;
+                    });
+                }
+                this.variableStatesToBeClosed.push(...stopedVariableStates);
+            };
+        });
+    }
+    subscribeVariableState(variableName) {
+        return this.subscribeVariableStates([variableName]).pipe(map(values => values[0]));
+    }
+    openVariables(variableNames, appId = '') {
+        return new Observable(observer => {
+            let variablesToStart = [];
+            each(variableNames, variableName => {
+                if (variableName) {
+                    if (!this.observers.has(variableName)) {
+                        this.observers.set(variableName, []);
+                        variablesToStart.push(variableName);
+                    }
+                    else {
+                        if (this.variableValueCache.has(variableName)) {
+                            observer.next([this.variableValueCache.get(variableName)]);
+                        }
+                    }
+                    this.observers.get(variableName).push(observer);
+                    if (!this.appIdVariablesMap.get(appId)) {
+                        this.appIdVariablesMap.set(appId, []);
+                    }
+                    else {
+                        if (this.appIdVariablesMap.get(appId).indexOf(variableName) === -1) {
+                            this.appIdVariablesMap.get(appId).push(variableName);
+                        }
+                    }
+                }
+            });
+            variablesToStart = uniq(variablesToStart);
+            if (variablesToStart && variablesToStart.length > 0) {
+                if (!this.variablesToBeOpened) {
+                    this.variablesToBeOpened = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.tryOpenVariables(this.variablesToBeOpened, appId);
+                        delete this.variablesToBeOpened;
+                    });
+                }
+                this.variablesToBeOpened.push(...variablesToStart);
+            }
+            return () => {
+                const stopedDataMonitorPoints = [];
+                each(variableNames, variableName => {
+                    const obs = this.observers.get(variableName);
+                    if (obs) {
+                        remove(obs, item => item === observer);
+                        if (obs.length <= 0) {
+                            this.observers.delete(variableName);
+                            stopedDataMonitorPoints.push(variableName);
+                        }
+                    }
+                });
+                if (!stopedDataMonitorPoints.length) {
+                    return;
+                }
+                if (!this.variablesToBeClosed) {
+                    this.variablesToBeClosed = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.tryStopVariables(this.variablesToBeClosed, appId);
+                        delete this.variablesToBeClosed;
+                    });
+                }
+                this.variablesToBeClosed.push(...stopedDataMonitorPoints);
+            };
+        });
+    }
+    openVariable(variableName, appId = '') {
+        if (!variableName) {
+            return;
+        }
+        return this.openVariables([variableName], appId).pipe(map(values => values[0]));
+    }
+    write(variableName, value) {
+        if (!variableName) {
+            return;
+        }
+        this.remoteVariableProtocol.writeVariable(variableName, value);
+        return new Observable(__ => {
+            /* do nothing right now, if want value change immediately, can use this code below:
+              observer.next(new VariableValue(variable, VariableStateEnum.DataNormal, value))*/
+        });
+    }
+    writeWordByBit(variableName, index, value) {
+        if (!variableName) {
+            return;
+        }
+        this.remoteVariableProtocol.writeVariableWordByBit(variableName, index, value);
+        return new Observable(__ => {
+            /* do nothing right now, if want value change immediately, can use this code below:
+              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);
+            };
+        });
+    }
+    dispose() {
+        // TODO调用所有的ob.complete()。
+        this.connectedSubscription.unsubscribe();
+        this.variableStatesChangedSubscription.unsubscribe();
+        this.variableValuesChangedSubscription.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

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

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

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { VariableValue } from '../../../communication';
+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>;
+    subscribeVariableStates(variableNames: string[]): Observable<void>;
+    unsubscribeVariableStates(variableNames: string[]): Observable<void>;
+    subscribeVirtualDeviceAlarms(appId: string): any;
+    unsubscribeVirtualDeviceAlarms(appId: string): any;
+}

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

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

package/remote/config/graph/get-released-graph-state-result.d.ts

@@ -0,0 +1,6 @@
+import { GraphStateResult } from './graph-state-result';
+export interface GetReleasedGraphStateResult {
+    graphId: number;
+    stateIndex: number;
+    result?: GraphStateResult;
+}

package/remote/config/graph/get-released-graph-state-result.metadata.json

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

package/remote/config/graph/get-released-graph-states.d.ts

@@ -0,0 +1,4 @@
+import { GraphState } from './graph-state';
+export interface GetReleasedGraphStates {
+    readonly states: GraphState[];
+}

package/remote/config/graph/get-released-graph-states.metadata.json

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

package/remote/config/graph/graph-state-key.d.ts

@@ -0,0 +1,6 @@
+import { GraphExtendedStyle } from '../../../shared/graph-extended-style';
+export interface GraphStateKey {
+    readonly graphId: string | number;
+    readonly stateId: number;
+    readonly extendedStyle?: GraphExtendedStyle;
+}

package/remote/config/graph/graph-state-key.metadata.json

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

package/remote/config/graph/graph-state-result.d.ts

@@ -0,0 +1,5 @@
+import { GraphType } from '../../../config/graph/graph-type';
+export interface GraphStateResult {
+    type: GraphType;
+    url: string;
+}

package/remote/config/graph/graph-state-result.metadata.json

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

package/remote/config/graph/graph-state.metadata.json

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

package/remote/config/graph/remote-graph-protocol.d.ts

@@ -0,0 +1,11 @@
+import { Observable } from 'rxjs';
+import { GetReleasedGraphStates } from './get-released-graph-states';
+import { GetReleasedGraphStateResult } from './get-released-graph-state-result';
+export interface RemoteGraphProtocol {
+    readonly version: number;
+    readonly remoteServiceBaseUrl: string;
+    getSystemGraphConfig(graphId: string): any;
+    getAbsoluteStateUrl(graphId: string, stateUrl: string): string;
+    getReleasedGraphStates(input: GetReleasedGraphStates): Observable<GetReleasedGraphStateResult[]>;
+    getGraphStateUrl(graphId: number, stateIndex: number, fill: string, stroke: string): string;
+}

package/remote/config/graph/remote-graph-protocol.metadata.json

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

package/remote/config/graph/remote-graph-store.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import { GraphResult, GraphStore } from '../../../config';
+import { GraphExtendedStyle } from '../../../shared';
+import { RemoteGraphProtocol } from './remote-graph-protocol';
+export declare class RemoteGraphStore implements GraphStore {
+    private readonly remoteGraphProtocol;
+    private readonly graphStateCache;
+    private graphStateToBeResolved;
+    constructor(remoteGraphProtocol: RemoteGraphProtocol);
+    getGraph(graphId: string | number, stateId: number, extendedStyle?: GraphExtendedStyle): Observable<GraphResult>;
+    private getSystemGraph;
+    private getImageUrl;
+    private getReleasedGraphState;
+    private getReleaseGraphStateWithExtendedStyle;
+    private resolvePendingStates;
+}

package/remote/config/graph/remote-graph-store.js

@@ -0,0 +1,101 @@
+import { find } from 'lodash';
+import { of, Subject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Graph, GraphResult, GraphType } from '../../../config';
+import { StringifyingMap } from '../../../core/stringifying-map';
+export class RemoteGraphStore {
+    constructor(remoteGraphProtocol) {
+        this.remoteGraphProtocol = remoteGraphProtocol;
+        this.graphStateCache = new StringifyingMap(k => JSON.stringify(k));
+    }
+    getGraph(graphId, stateId, extendedStyle) {
+        const graphStateKey = { graphId, stateId, extendedStyle };
+        if (this.graphStateCache.has(graphStateKey)) {
+            return of(this.graphStateCache.get(graphStateKey));
+        }
+        const version = this.remoteGraphProtocol.version;
+        if (version >= 1) {
+            return this.getReleasedGraphState(graphStateKey);
+        }
+        else {
+            return this.getSystemGraph(graphStateKey);
+        }
+    }
+    getSystemGraph(graphStateKey) {
+        const graphId = String(graphStateKey.graphId);
+        return this.remoteGraphProtocol.getSystemGraphConfig(graphId).pipe(map((graphConfig) => {
+            let result;
+            const stateConfig = find(graphConfig.states, s => s.id === graphStateKey.stateId);
+            if (stateConfig) {
+                const graphType = stateConfig.type === 'svg' ? GraphType.SVG : GraphType.Image;
+                const graph = new Graph(graphType, this.remoteGraphProtocol.getAbsoluteStateUrl(graphId, stateConfig.url));
+                result = GraphResult.success(graph);
+            }
+            else {
+                result = GraphResult.failed();
+            }
+            this.graphStateCache.set(graphStateKey, result);
+            return result;
+        }));
+    }
+    getImageUrl(url) {
+        if (!url) {
+            return url;
+        }
+        if (url.indexOf('http://') === 0 || url.indexOf('https://') === 0) {
+            return url;
+        }
+        return this.remoteGraphProtocol.remoteServiceBaseUrl + url;
+    }
+    getReleasedGraphState(graphStateKey) {
+        if (graphStateKey.extendedStyle) {
+            return this.getReleaseGraphStateWithExtendedStyle(graphStateKey);
+        }
+        if (!this.graphStateToBeResolved) {
+            this.graphStateToBeResolved =
+                new StringifyingMap(k => JSON.stringify(k));
+            setTimeout(() => { this.resolvePendingStates(); });
+        }
+        if (!this.graphStateToBeResolved.has(graphStateKey)) {
+            this.graphStateToBeResolved.set(graphStateKey, new Subject());
+        }
+        return this.graphStateToBeResolved.get(graphStateKey);
+    }
+    getReleaseGraphStateWithExtendedStyle(graphStateKey) {
+        const graphId = Number(graphStateKey.graphId);
+        const fill = encodeURIComponent(graphStateKey.extendedStyle.fill);
+        const stroke = encodeURIComponent(graphStateKey.extendedStyle.stroke);
+        const url = this.remoteGraphProtocol.getGraphStateUrl(graphId, graphStateKey.stateId, fill, stroke);
+        const graph = new Graph(GraphType.SVG, url);
+        return of(GraphResult.success(graph));
+    }
+    resolvePendingStates() {
+        const graphStateToBeResolved = this.graphStateToBeResolved;
+        const states = [];
+        graphStateToBeResolved.forEach((__, key) => {
+            const graphState = JSON.parse(key);
+            states.push({ graphId: graphState.graphId, stateIndex: graphState.stateId });
+        });
+        const dto = { states: states };
+        this.remoteGraphProtocol.getReleasedGraphStates(dto).subscribe(result => {
+            result.forEach(value => {
+                const key = { graphId: value.graphId, stateId: value.stateIndex };
+                let graphResult;
+                if (value.result) {
+                    const url = this.getImageUrl(value.result.url);
+                    graphResult = GraphResult.success(new Graph(value.result.type, url));
+                }
+                else {
+                    graphResult = GraphResult.failed();
+                }
+                this.graphStateCache.set(key, graphResult);
+                const subject = graphStateToBeResolved.get(key);
+                if (subject) {
+                    subject.next(graphResult);
+                    subject.complete();
+                }
+            });
+        });
+        delete this.graphStateToBeResolved;
+    }
+}

package/remote/config/graph/remote-graph-store.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"RemoteGraphStore":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./remote-graph-protocol","name":"RemoteGraphProtocol","line":16,"character":54}]}],"getGraph":[{"__symbolic":"method"}],"getSystemGraph":[{"__symbolic":"method"}],"getImageUrl":[{"__symbolic":"method"}],"getReleasedGraphState":[{"__symbolic":"method"}],"getReleaseGraphStateWithExtendedStyle":[{"__symbolic":"method"}],"resolvePendingStates":[{"__symbolic":"method"}]}}}}]

package/remote/config/image/remote-image-protocol.d.ts

@@ -0,0 +1,4 @@
+export interface RemoteImageProtocol {
+    readonly remoteServiceBaseUrl: string;
+    readonly appBaseUrl: string;
+}

package/remote/config/image/remote-image-protocol.metadata.json

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

package/remote/config/image/remote-image-store.d.ts

@@ -0,0 +1,8 @@
+import { ImageStore } from '../../../config';
+import { RemoteImageProtocol } from './remote-image-protocol';
+export declare class RemoteImageStore implements ImageStore {
+    private readonly remoteImageProtocol;
+    constructor(remoteImageProtocol: RemoteImageProtocol);
+    private getDiagramImageUrlPrefix;
+    getImageUrl(imageId: string): string;
+}

package/remote/config/image/remote-image-store.js

@@ -0,0 +1,19 @@
+const defaultImageId = 'defaultImage';
+const defaultImageSource = '/assets/common/images/configure/defaultImage.png';
+// 获取组态图片Controller方法的Url路径
+const getDiagramImageMethodPath = '/ConfigureComponent/GetImage';
+const idQueryStringPrefix = 'id=';
+export class RemoteImageStore {
+    constructor(remoteImageProtocol) {
+        this.remoteImageProtocol = remoteImageProtocol;
+    }
+    getDiagramImageUrlPrefix() {
+        return this.remoteImageProtocol.remoteServiceBaseUrl + getDiagramImageMethodPath + '?';
+    }
+    getImageUrl(imageId) {
+        if (!imageId || imageId === defaultImageId) {
+            return this.remoteImageProtocol.appBaseUrl + defaultImageSource;
+        }
+        return this.getDiagramImageUrlPrefix() + idQueryStringPrefix + imageId;
+    }
+}

package/remote/config/image/remote-image-store.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"RemoteImageStore":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./remote-image-protocol","name":"RemoteImageProtocol","line":14,"character":54}]}],"getDiagramImageUrlPrefix":[{"__symbolic":"method"}],"getImageUrl":[{"__symbolic":"method"}]}}}}]

package/remote/config/view/remote-view-protocol.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from 'rxjs';
+import { ViewResult } from './view-result';
+export interface RemoteViewProtocol {
+    getReleasedMainView(): Observable<ViewResult>;
+    getReleasedView(viewIndex: number): Observable<ViewResult>;
+    getViewConfigByConfigureViewId(configureViewId: number): Observable<ViewResult>;
+    getViewConfigByConfigureViewCode(configureViewCode: string): Observable<ViewResult>;
+}

package/remote/config/view/remote-view-protocol.metadata.json

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

package/remote/config/view/remote-view-store.d.ts

@@ -0,0 +1,13 @@
+import { Observable } from 'rxjs';
+import { ViewStore } from '../../../config/view/view-store';
+import { ViewModel } from '../../../config/view/view.model';
+import { RemoteViewProtocol } from './remote-view-protocol';
+export declare class RemoteViewStore implements ViewStore {
+    private readonly remoteViewProtocol;
+    private readonly viewConfigCache;
+    constructor(remoteViewProtocol: RemoteViewProtocol);
+    getMainViewConfig(): Observable<ViewModel>;
+    getViewConfig(viewIndex: number): Observable<ViewModel>;
+    getViewConfigByConfigureViewId(configureViewId: number): Observable<ViewModel>;
+    getViewConfigByConfigureViewCode(configureViewCode: string): Observable<ViewModel>;
+}

package/remote/config/view/remote-view-store.js

@@ -0,0 +1,39 @@
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { ViewModel } from '../../../config/view/view.model';
+import { StringifyingMap } from '../../../core/stringifying-map';
+export class RemoteViewStore {
+    constructor(remoteViewProtocol) {
+        this.remoteViewProtocol = remoteViewProtocol;
+        this.viewConfigCache = new StringifyingMap(k => JSON.stringify(k));
+    }
+    getMainViewConfig() {
+        return this.remoteViewProtocol.getReleasedMainView().pipe(map(view => {
+            const result = new ViewModel(view.content);
+            this.viewConfigCache.set(view.viewIndex, result);
+            return result;
+        }));
+    }
+    getViewConfig(viewIndex) {
+        if (this.viewConfigCache.has(viewIndex)) {
+            return of(this.viewConfigCache.get(viewIndex));
+        }
+        return this.remoteViewProtocol.getReleasedView(viewIndex).pipe(map(config => {
+            const result = new ViewModel(config.content);
+            this.viewConfigCache.set(viewIndex, result);
+            return result;
+        }));
+    }
+    getViewConfigByConfigureViewId(configureViewId) {
+        return this.remoteViewProtocol.getViewConfigByConfigureViewId(configureViewId).pipe(map(config => {
+            const result = new ViewModel(config.content);
+            return result;
+        }));
+    }
+    getViewConfigByConfigureViewCode(configureViewCode) {
+        return this.remoteViewProtocol.getViewConfigByConfigureViewCode(configureViewCode).pipe(map(config => {
+            const result = new ViewModel(config.content);
+            return result;
+        }));
+    }
+}

package/remote/config/view/remote-view-store.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"RemoteViewStore":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","module":"./remote-view-protocol","name":"RemoteViewProtocol","line":12,"character":53}]}],"getMainViewConfig":[{"__symbolic":"method"}],"getViewConfig":[{"__symbolic":"method"}],"getViewConfigByConfigureViewId":[{"__symbolic":"method"}],"getViewConfigByConfigureViewCode":[{"__symbolic":"method"}]}}}}]

package/remote/config/view/view-result.metadata.json

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

package/remote/index.d.ts

@@ -0,0 +1,14 @@
+export { GetReleasedGraphStateResult } from './config/graph/get-released-graph-state-result';
+export { GraphStateResult } from './config/graph/graph-state-result';
+export { GetReleasedGraphStates } from './config/graph/get-released-graph-states';
+export { GraphStateKey } from './config/graph/graph-state-key';
+export { GraphState } from './config/graph/graph-state';
+export { RemoteGraphProtocol } from './config/graph/remote-graph-protocol';
+export { RemoteGraphStore } from './config/graph/remote-graph-store';
+export { RemoteViewProtocol } from './config/view/remote-view-protocol';
+export { RemoteViewStore } from './config/view/remote-view-store';
+export { ViewResult } from './config/view/view-result';
+export { RemoteImageProtocol } from './config/image/remote-image-protocol';
+export { RemoteImageStore } from './config/image/remote-image-store';
+export { RemoteVariableCommunicator } from './communication/variable/remote-variable-communicator';
+export { RemoteVariableProtocol } from './communication/variable/remote-variable-protocol';

package/remote/index.js

@@ -0,0 +1,4 @@
+export { RemoteGraphStore } from './config/graph/remote-graph-store';
+export { RemoteViewStore } from './config/view/remote-view-store';
+export { RemoteImageStore } from './config/image/remote-image-store';
+export { RemoteVariableCommunicator } from './communication/variable/remote-variable-communicator';

package/remote/index.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{},"exports":[{"from":"./config/graph/get-released-graph-state-result","export":["GetReleasedGraphStateResult"]},{"from":"./config/graph/graph-state-result","export":["GraphStateResult"]},{"from":"./config/graph/get-released-graph-states","export":["GetReleasedGraphStates"]},{"from":"./config/graph/graph-state-key","export":["GraphStateKey"]},{"from":"./config/graph/graph-state","export":["GraphState"]},{"from":"./config/graph/remote-graph-protocol","export":["RemoteGraphProtocol"]},{"from":"./config/graph/remote-graph-store","export":["RemoteGraphStore"]},{"from":"./config/view/remote-view-protocol","export":["RemoteViewProtocol"]},{"from":"./config/view/remote-view-store","export":["RemoteViewStore"]},{"from":"./config/view/view-result","export":["ViewResult"]},{"from":"./config/image/remote-image-protocol","export":["RemoteImageProtocol"]},{"from":"./config/image/remote-image-store","export":["RemoteImageStore"]},{"from":"./communication/variable/remote-variable-communicator","export":["RemoteVariableCommunicator"]},{"from":"./communication/variable/remote-variable-protocol","export":["RemoteVariableProtocol"]}]}]

package/security/index.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{},"exports":[{"from":"./security-checker","export":["SecurityChecker"]}]}]

package/security/security-checker.metadata.json

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

package/service/index.metadata.json

@@ -0,0 +1 @@
+[{"__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"}]}]