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

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

@@ -1,254 +0,0 @@
-import { each, remove, uniq } from 'lodash';
-import { Observable, Subscriber, Subscription } from 'rxjs';
-import { map } from 'rxjs/operators';
-import { VariableCommunicator, VariableValue, VariableState } from '../../../communication';
-import { StringifyingMap } from '../../../core';
-import { LoggerService } from '../../../logger';
-import { RemoteVariableProtocol } from './remote-variable-protocol';
-
-export class RemoteVariableCommunicator implements VariableCommunicator {
-
-    private observers = new Map<string, Subscriber<VariableValue[]>[]>();
-    private appIdVariablesMap = new Map<string, string[]>();
-    private connectedSubscription: Subscription;
-    private variableValuesChangedSubscription: Subscription;
-    private variablesToBeOpened: string[];
-    private variablesToBeClosed: string[];
-    private variableValueCache: StringifyingMap<string, VariableValue>;
-
-    private variableStateObservers = new Map<string, Subscriber<VariableState[]>[]>();
-    private variableStatesChangedSubscription: Subscription;
-    private variableStateCache = new Map<string, VariableState>();
-    private variableStatesToBeOpened: string[];
-    private variableStatesToBeClosed: string[];
-
-    private alarmObservers: Subscriber<any[]>[] = [];
-    private alarmChangedSubscription: Subscription;
-
-    constructor(private readonly remoteVariableProtocol: RemoteVariableProtocol, private readonly logger: LoggerService) {
-        this.variableValueCache = new StringifyingMap<string, VariableValue>(k => JSON.stringify(k));
-        this.connectedSubscription = this.remoteVariableProtocol.connected.subscribe(() => {
-
-            const variableNamesToStart: Array<string> = [];
-            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();
-    }
-
-    private doAlarmChanged() {
-        if (this.alarmChangedSubscription !== undefined) {
-            this.alarmChangedSubscription.unsubscribe();
-        }
-        this.alarmChangedSubscription = this.remoteVariableProtocol.virtualDeviceAlarmsChanged.subscribe((alarms) => {
-            each(this.alarmObservers, ob => {
-                ob.next(alarms);
-            });
-
-        });
-    }
-
-    private doVariableValuesChanged() {
-        if (this.variableValuesChangedSubscription !== undefined) {
-            this.variableValuesChangedSubscription.unsubscribe();
-        }
-        this.variableValuesChangedSubscription =
-            this.remoteVariableProtocol.variableValuesChanged.subscribe((values: VariableValue[]) => {
-                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]);
-                        });
-                    }
-                });
-            });
-    }
-
-    private doVariableStatesChanged() {
-        if (this.variableStatesChangedSubscription !== undefined) {
-            this.variableStatesChangedSubscription.unsubscribe();
-        }
-        this.variableStatesChangedSubscription =
-            this.remoteVariableProtocol.variableStatesChanged.subscribe((states: VariableState[]) => {
-                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: string[]): Observable<VariableState[]> {
-        return new Observable<VariableState[]>(observer => {
-            let variableNamesToStart: string[] = [];
-            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: string): Observable<VariableState> {
-        return this.subscribeVariableStates([variableName]).pipe(map<VariableState[], VariableState>(values => values[0]));
-    }
-
-    openVariables(variableNames: string[], appId = ''): Observable<VariableValue[]> {
-        return new Observable<VariableValue[]>(observer => {
-            let variablesToStart: string[] = [];
-            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: string, appId = ''): Observable<VariableValue> {
-        if (!variableName) { return; }
-        return this.openVariables([variableName], appId).pipe(map(values => values[0]));
-    }
-
-    write(variableName: string, value: any): Observable<VariableValue> {
-        if (!variableName) { return; }
-        this.remoteVariableProtocol.writeVariable(variableName, value);
-        return new Observable<VariableValue>(__ => {
-            /* do nothing right now, if want value change immediately, can use this code below:
-              observer.next(new VariableValue(variable, VariableStateEnum.DataNormal, value))*/
-        });
-    }
-
-    writeWordByBit(variableName: string, index: number, value: number): Observable<VariableValue> {
-        if (!variableName) { return; }
-        this.remoteVariableProtocol.writeVariableWordByBit(variableName, index, value);
-        return new Observable<VariableValue>(__ => {
-            /* 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<any[]>(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/src/remote/communication/variable/remote-variable-protocol.ts

@@ -1,29 +0,0 @@
-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);
-
-    unsubscribeVirtualDeviceAlarms(appId: string);
-}

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

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

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

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

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

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

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

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

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

@@ -1,19 +0,0 @@
-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/src/remote/config/graph/remote-graph-store.ts

@@ -1,112 +0,0 @@
-import { find } from 'lodash';
-import { Observable, of, Subject } from 'rxjs';
-import { map } from 'rxjs/operators';
-import { Graph, GraphResult, GraphStore, GraphType } from '../../../config';
-import { StringifyingMap } from '../../../core/stringifying-map';
-import { GraphExtendedStyle } from '../../../shared';
-import { GraphState } from './graph-state';
-import { GraphStateKey } from './graph-state-key';
-import { RemoteGraphProtocol } from './remote-graph-protocol';
-
-export class RemoteGraphStore implements GraphStore {
-
-    private readonly graphStateCache = new StringifyingMap<GraphStateKey, GraphResult>(k => JSON.stringify(k));
-
-    private graphStateToBeResolved: StringifyingMap<GraphStateKey, Subject<GraphResult>>;
-
-    constructor(private readonly remoteGraphProtocol: RemoteGraphProtocol) {
-    }
-
-    getGraph(graphId: string | number, stateId: number, extendedStyle?: GraphExtendedStyle): Observable<GraphResult> {
-        const graphStateKey: 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);
-        }
-    }
-
-    private getSystemGraph(graphStateKey: GraphStateKey): Observable<GraphResult> {
-        const graphId = String(graphStateKey.graphId);
-        return this.remoteGraphProtocol.getSystemGraphConfig(graphId).pipe(map((graphConfig: any) => {
-            let result: GraphResult;
-            const stateConfig: any = find(graphConfig.states, s => (<any>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;
-        }));
-    }
-
-    private getImageUrl(url: string) {
-        if (!url) {
-            return url;
-        }
-        if (url.indexOf('http://') === 0 || url.indexOf('https://') === 0) {
-            return url;
-        }
-        return this.remoteGraphProtocol.remoteServiceBaseUrl + url;
-    }
-
-    private getReleasedGraphState(graphStateKey: GraphStateKey): Observable<GraphResult> {
-        if (graphStateKey.extendedStyle) { return this.getReleaseGraphStateWithExtendedStyle(graphStateKey); }
-        if (!this.graphStateToBeResolved) {
-            this.graphStateToBeResolved =
-                new StringifyingMap<GraphStateKey, Subject<GraphResult>>(k => JSON.stringify(k));
-            setTimeout(() => { this.resolvePendingStates(); });
-        }
-        if (!this.graphStateToBeResolved.has(graphStateKey)) {
-            this.graphStateToBeResolved.set(graphStateKey, new Subject<GraphResult>());
-        }
-        return this.graphStateToBeResolved.get(graphStateKey);
-    }
-
-    private getReleaseGraphStateWithExtendedStyle(graphStateKey: GraphStateKey): Observable<GraphResult> {
-        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));
-    }
-
-    private resolvePendingStates() {
-        const graphStateToBeResolved = this.graphStateToBeResolved;
-        const states: GraphState[] = [];
-        graphStateToBeResolved.forEach((__, key) => {
-            const graphState: GraphStateKey = JSON.parse(key);
-            states.push({ graphId: graphState.graphId as number, stateIndex: graphState.stateId });
-        });
-        const dto = { states: states };
-        this.remoteGraphProtocol.getReleasedGraphStates(dto).subscribe(
-            result => {
-                result.forEach(value => {
-                    const key: GraphStateKey = { graphId: value.graphId, stateId: value.stateIndex };
-                    let graphResult: 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/src/remote/config/image/remote-image-protocol.ts

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

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

@@ -1,29 +0,0 @@
-import { ImageStore } from '../../../config';
-import { RemoteImageProtocol } from './remote-image-protocol';
-
-const defaultImageId = 'defaultImage';
-
-const defaultImageSource = '/assets/common/images/configure/defaultImage.png';
-
-// 获取组态图片Controller方法的Url路径
-const getDiagramImageMethodPath = '/ConfigureComponent/GetImage';
-
-const idQueryStringPrefix = 'id=';
-
-export class RemoteImageStore implements ImageStore {
-
-    constructor(private readonly remoteImageProtocol: RemoteImageProtocol) {
-    }
-
-    private getDiagramImageUrlPrefix() {
-        return this.remoteImageProtocol.remoteServiceBaseUrl + getDiagramImageMethodPath + '?';
-    }
-
-    getImageUrl(imageId: string): string {
-        if (!imageId || imageId === defaultImageId) {
-            return this.remoteImageProtocol.appBaseUrl + defaultImageSource;
-        }
-        return this.getDiagramImageUrlPrefix() + idQueryStringPrefix + imageId;
-    }
-
-}

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

@@ -1,14 +0,0 @@
-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/src/remote/config/view/remote-view-store.ts

@@ -1,52 +0,0 @@
-import { Observable, of } from 'rxjs';
-import { map } from 'rxjs/operators';
-
-import { ViewStore } from '../../../config/view/view-store';
-import { ViewModel } from '../../../config/view/view.model';
-import { StringifyingMap } from '../../../core/stringifying-map';
-import { RemoteViewProtocol } from './remote-view-protocol';
-
-export class RemoteViewStore implements ViewStore {
-
-    private readonly viewConfigCache = new StringifyingMap<number, ViewModel>(k => JSON.stringify(k));
-
-    constructor(private readonly remoteViewProtocol: RemoteViewProtocol) {
-    }
-
-    getMainViewConfig(): Observable<ViewModel> {
-        return this.remoteViewProtocol.getReleasedMainView().pipe(
-            map(view => {
-                const result = new ViewModel(view.content);
-                this.viewConfigCache.set(view.viewIndex, result);
-                return result;
-            }));
-    }
-
-    getViewConfig(viewIndex: number): Observable<ViewModel> {
-        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: number): Observable<ViewModel> {
-        return this.remoteViewProtocol.getViewConfigByConfigureViewId(configureViewId).pipe(
-            map(config => {
-                const result = new ViewModel(config.content);
-                return result;
-            }));
-    }
-
-    getViewConfigByConfigureViewCode(configureViewCode: string): Observable<ViewModel> {
-        return this.remoteViewProtocol.getViewConfigByConfigureViewCode(configureViewCode).pipe(
-            map(config => {
-                const result = new ViewModel(config.content);
-                return result;
-            }));
-    }
-}

package/src/remote/index.ts

@@ -1,17 +0,0 @@
-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/src/service/operation-record/create-operation-record-args.ts

@@ -1,6 +0,0 @@
-import { VariableOptionModel } from './variable-option.model';
-
-export interface CreateOperationRecordArgs {
-    readonly variableOptionModel?: VariableOptionModel;
-    readonly operationDescription: string;
-}

package/src/service/operation-record/index.ts

@@ -1,5 +0,0 @@
-export { CreateOperationRecordArgs } from './create-operation-record-args';
-
-export { OperationRecordService } from './operation-record.service';
-
-export { VariableOptionModel } from './variable-option.model';

package/src/service/operation-record/operation-record.service.ts

@@ -1,5 +0,0 @@
-import { CreateOperationRecordArgs } from './create-operation-record-args';
-
-export interface OperationRecordService {
-    record(args: CreateOperationRecordArgs): void;
-}

package/src/service/operation-record/variable-option.model.ts

@@ -1,6 +0,0 @@
-
-export interface VariableOptionModel {
-    readonly variableName: string;
-    readonly originValue: any;
-    newValue: any;
-}

package/src/service/released-variable/released-variable.service.ts

@@ -1,5 +0,0 @@
-import { Observable } from 'rxjs';
-
-export interface ReleasedVariableService {
-    getVariableWithValueTransform(variableName): Observable<any>;
-}

package/src/service/video/video.service.ts

@@ -1,5 +0,0 @@
-import { VideoUrl } from './video-url';
-
-export interface VideoService {
-    getVideoUrl(tag: string): Promise<VideoUrl>;
-}

package/src/service/weather.service.ts

@@ -1,7 +0,0 @@
-export interface WeatherService {
-
-    getWeatherInfo(): Promise<any>;
-
-    getAirQualityInfo(): Promise<any>;
-
-}

package/src/settings/display-mode.ts

@@ -1,12 +0,0 @@
-export enum DisplayMode {
-
-    /**
-     * 网页版显示模式
-     */
-    Web,
-
-    /**
-     * 移动端显示，优化部分元件在移动端中的显示效果
-     */
-    Mobile
-}

package/src/settings/global-settings.ts

@@ -1,11 +0,0 @@
-import { Injectable } from '@angular/core';
-import { DisplayMode } from './display-mode';
-
-@Injectable()
-export class GlobalSettings {
-
-    /**
-     * 元件展示模式：网页版、移动版
-     */
-    displayMode: DisplayMode;
-}

package/src/settings/view-resize-mode.ts

@@ -1,12 +0,0 @@
-export enum ViewResizeMode {
-
-    /**
-     * 在保持纵横比的同时等比缩放显示所有内容
-     */
-    Uniform,
-
-    /**
-     * 在保持纵横比的同时保证横向显示尽可能多的空间，
-     */
-    HorizontalUniform
-}