@flexem/fc-gui 3.0.0-alpha.16 → 3.0.0-alpha.160

package/model/shared/dynamic-display/dynamic-display.js

@@ -1,35 +1,35 @@
-import { EventEmitter } from '@angular/core';
-import { RotationBehavior } from '../rotation/rotation-behavior';
-import { TranslationDirectionType } from '../translation/translation-direction-type';
-import { TranslationBehavior } from '../translation/translation-behavior';
-import { DynamicDisplayResultModel } from './dynamic-display-result-model';
-import { DynamicBehaviorType } from './dynamic-behavior-type';
-export class DynamicDisplay {
-    constructor(dynamicDisplay, variableCommunicator, variableStore, location, signalRAppId) {
-        this.doBehavior = new EventEmitter();
-        if (dynamicDisplay.isHorizontalTranslation && dynamicDisplay.horizontalTranslation != null) {
-            // tslint:disable-next-line:max-line-length
-            const horizontalBehavior = new TranslationBehavior(dynamicDisplay.horizontalTranslation, variableCommunicator, variableStore, TranslationDirectionType.Horizontal, location, signalRAppId);
-            horizontalBehavior.doTranslation.subscribe(tanslation => {
-                // tslint:disable-next-line:max-line-length
-                const dynamicDisplayResult = new DynamicDisplayResultModel(tanslation, undefined, DynamicBehaviorType.HorizontalTranslation);
-                this.doBehavior.emit(dynamicDisplayResult);
-            });
-        }
-        if (dynamicDisplay.isVerticalTranslation && dynamicDisplay.verticalTranslation != null) {
-            // tslint:disable-next-line:max-line-length
-            const verticalBehavior = new TranslationBehavior(dynamicDisplay.verticalTranslation, variableCommunicator, variableStore, TranslationDirectionType.Vertical, location, signalRAppId);
-            verticalBehavior.doTranslation.subscribe(tanslation => {
-                const dynamicDisplayResult = new DynamicDisplayResultModel(tanslation, undefined, DynamicBehaviorType.VerticalTranslation);
-                this.doBehavior.emit(dynamicDisplayResult);
-            });
-        }
-        if (dynamicDisplay.isRotation && dynamicDisplay.rotation != null) {
-            const rotationBehavior = new RotationBehavior(dynamicDisplay.rotation, variableCommunicator, variableStore, signalRAppId);
-            rotationBehavior.doRotation.subscribe(angel => {
-                const dynamicDisplayResult = new DynamicDisplayResultModel(undefined, angel, DynamicBehaviorType.Rotation);
-                this.doBehavior.emit(dynamicDisplayResult);
-            });
-        }
-    }
-}
+import { EventEmitter } from '@angular/core';
+import { RotationBehavior } from '../rotation/rotation-behavior';
+import { TranslationDirectionType } from '../translation/translation-direction-type';
+import { TranslationBehavior } from '../translation/translation-behavior';
+import { DynamicDisplayResultModel } from './dynamic-display-result-model';
+import { DynamicBehaviorType } from './dynamic-behavior-type';
+export class DynamicDisplay {
+    constructor(dynamicDisplay, variableCommunicator, variableStore, location, signalRAppId) {
+        this.doBehavior = new EventEmitter();
+        if (dynamicDisplay.isHorizontalTranslation && dynamicDisplay.horizontalTranslation != null) {
+            // tslint:disable-next-line:max-line-length
+            const horizontalBehavior = new TranslationBehavior(dynamicDisplay.horizontalTranslation, variableCommunicator, variableStore, TranslationDirectionType.Horizontal, location, signalRAppId);
+            horizontalBehavior.doTranslation.subscribe(tanslation => {
+                // tslint:disable-next-line:max-line-length
+                const dynamicDisplayResult = new DynamicDisplayResultModel(tanslation, undefined, DynamicBehaviorType.HorizontalTranslation);
+                this.doBehavior.emit(dynamicDisplayResult);
+            });
+        }
+        if (dynamicDisplay.isVerticalTranslation && dynamicDisplay.verticalTranslation != null) {
+            // tslint:disable-next-line:max-line-length
+            const verticalBehavior = new TranslationBehavior(dynamicDisplay.verticalTranslation, variableCommunicator, variableStore, TranslationDirectionType.Vertical, location, signalRAppId);
+            verticalBehavior.doTranslation.subscribe(tanslation => {
+                const dynamicDisplayResult = new DynamicDisplayResultModel(tanslation, undefined, DynamicBehaviorType.VerticalTranslation);
+                this.doBehavior.emit(dynamicDisplayResult);
+            });
+        }
+        if (dynamicDisplay.isRotation && dynamicDisplay.rotation != null) {
+            const rotationBehavior = new RotationBehavior(dynamicDisplay.rotation, variableCommunicator, variableStore, signalRAppId);
+            rotationBehavior.doRotation.subscribe(angel => {
+                const dynamicDisplayResult = new DynamicDisplayResultModel(undefined, angel, DynamicBehaviorType.Rotation);
+                this.doBehavior.emit(dynamicDisplayResult);
+            });
+        }
+    }
+}

package/model/shared/graph/custom-style.d.ts

@@ -1,14 +1,14 @@
-export interface CustomStyle {
-    /**
-     * 版本1：废弃掉state、stateId。改用stateIndex表示状态索引。
-     */
-    version?: number;
-    state?: string;
-    stateId?: number;
-    stateIndex: number;
-    /**
-     * CustomStyle
-     */
-    stroke?: string;
-    fill?: string;
-}
+export interface CustomStyle {
+    /**
+     * 版本1：废弃掉state、stateId。改用stateIndex表示状态索引。
+     */
+    version?: number;
+    state?: string;
+    stateId?: number;
+    stateIndex: number;
+    /**
+     * CustomStyle
+     */
+    stroke?: string;
+    fill?: string;
+}

package/model/shared/graph/graph-setting.d.ts

@@ -1,10 +1,10 @@
-import { CustomStyle } from './custom-style';
-export interface GraphSetting {
-    /**
-     * @type {(string | number)}
-     * @memberof GraphSetting
-     * @description 旧版本使用的string指向系统图库.新版本使用的number指向当前工程图库。
-     */
-    readonly id: string | number;
-    readonly styles?: CustomStyle[];
-}
+import { CustomStyle } from './custom-style';
+export interface GraphSetting {
+    /**
+     * @type {(string | number)}
+     * @memberof GraphSetting
+     * @description 旧版本使用的string指向系统图库.新版本使用的number指向当前工程图库。
+     */
+    readonly id: string | number;
+    readonly styles?: CustomStyle[];
+}

package/model/shared/index.d.ts

@@ -1,8 +1,8 @@
-export * from './condition';
-export * from './text';
-export { Size } from './size.model';
-export { Point } from './point.model';
-export { GraphSetting } from './graph/graph-setting';
-export { CustomStyle } from './graph/custom-style';
-export * from './state';
-export { ArcModel } from './arc.model';
+export * from './condition';
+export * from './text';
+export { Size } from './size.model';
+export { Point } from './point.model';
+export { GraphSetting } from './graph/graph-setting';
+export { CustomStyle } from './graph/custom-style';
+export * from './state';
+export { ArcModel } from './arc.model';

package/model/shared/index.js

@@ -1,3 +1,3 @@
-export * from './condition';
-export { Size } from './size.model';
-export * from './state';
+export * from './condition';
+export { Size } from './size.model';
+export * from './state';

package/model/shared/point.model.d.ts

@@ -1,4 +1,4 @@
-export interface Point {
-    x: number;
-    y: number;
-}
+export interface Point {
+    x: number;
+    y: number;
+}

package/model/shared/rotation/rotation-behavior-model.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from '@angular/core';
-export interface RotationBehaviorModel {
-    readonly doRotation: EventEmitter<number>;
-}
+import { EventEmitter } from '@angular/core';
+export interface RotationBehaviorModel {
+    readonly doRotation: EventEmitter<number>;
+}

package/model/shared/rotation/rotation-behavior.d.ts

@@ -1,9 +1,9 @@
-import { EventEmitter } from '@angular/core';
-import { RotationBehaviorModel } from './rotation-behavior-model';
-import { VariableCommunicator } from '../../../communication';
-import { RotationModel } from './rotation-model';
-import { VariableStore } from '../../../config';
-export declare class RotationBehavior implements RotationBehaviorModel {
-    readonly doRotation: EventEmitter<number>;
-    constructor(rotationModel: RotationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, signalRAppId: string);
-}
+import { EventEmitter } from '@angular/core';
+import { RotationBehaviorModel } from './rotation-behavior-model';
+import { VariableCommunicator } from '../../../communication';
+import { RotationModel } from './rotation-model';
+import { VariableStore } from '../../../config';
+export declare class RotationBehavior implements RotationBehaviorModel {
+    readonly doRotation: EventEmitter<number>;
+    constructor(rotationModel: RotationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, signalRAppId: string);
+}

package/model/shared/rotation/rotation-behavior.js

@@ -1,101 +1,101 @@
-import { EventEmitter } from '@angular/core';
-import { RotationDirectionType } from './rotation-direction-type';
-import { RotationObserver } from './rotation-observer';
-export class RotationBehavior {
-    constructor(rotationModel, variableCommunicator, variableStore, signalRAppId) {
-        this.doRotation = new EventEmitter();
-        const rotationObserver = new RotationObserver(rotationModel, variableCommunicator, variableStore, signalRAppId);
-        rotationObserver.rotationValueChanged.subscribe(rotationValue => {
-            if (+rotationModel.rotationDirection === RotationDirectionType.ClockWise) {
-                let newRotation;
-                if (rotationModel.isProportion === true) {
-                    const proportion = (rotationModel.maxAngle - rotationModel.minAngle)
-                        / (rotationModel.maxProportionScale - rotationModel.minProportionScale);
-                    if (rotationModel.isReverseProportion === true) {
-                        if (rotationValue > rotationModel.maxProportionScale) {
-                            newRotation = rotationModel.minAngle;
-                        }
-                        else if (rotationValue < rotationModel.minProportionScale) {
-                            newRotation = rotationModel.maxAngle;
-                        }
-                        else {
-                            newRotation = rotationModel.maxAngle - (rotationValue - rotationModel.minProportionScale) * proportion;
-                        }
-                    }
-                    else {
-                        if (rotationValue > rotationModel.maxProportionScale) {
-                            newRotation = rotationModel.maxAngle;
-                        }
-                        else if (rotationValue < rotationModel.minProportionScale) {
-                            newRotation = rotationModel.minAngle;
-                        }
-                        else {
-                            newRotation = rotationModel.minAngle + (rotationValue - rotationModel.minProportionScale) * proportion;
-                        }
-                    }
-                    this.doRotation.emit(newRotation);
-                }
-                else {
-                    if (rotationValue < rotationModel.minAngle) {
-                        this.doRotation.emit(rotationModel.minAngle);
-                    }
-                    else if (rotationValue > rotationModel.maxAngle) {
-                        this.doRotation.emit(rotationModel.maxAngle);
-                    }
-                    else {
-                        this.doRotation.emit(rotationValue);
-                    }
-                }
-            }
-            else if (+rotationModel.rotationDirection === RotationDirectionType.ReverseClockWise) {
-                let newRotation;
-                const nowMin = 360 - rotationModel.maxAngle;
-                const nowMax = 360 - rotationModel.minAngle;
-                if (rotationModel.isProportion === true) {
-                    const proportion = (nowMax - nowMin) / (rotationModel.maxProportionScale - rotationModel.minProportionScale);
-                    if (rotationModel.isReverseProportion === true) {
-                        if (rotationValue > rotationModel.maxProportionScale) {
-                            newRotation = nowMax;
-                        }
-                        else if (rotationValue < rotationModel.minProportionScale) {
-                            newRotation = nowMin;
-                        }
-                        else {
-                            newRotation = nowMin + (rotationValue - rotationModel.minProportionScale) * proportion;
-                        }
-                    }
-                    else {
-                        if (rotationValue > rotationModel.maxProportionScale) {
-                            newRotation = nowMin;
-                        }
-                        else if (rotationValue < rotationModel.minProportionScale) {
-                            newRotation = nowMax;
-                        }
-                        else {
-                            newRotation = nowMax - (rotationValue - rotationModel.minProportionScale) * proportion;
-                        }
-                        if (newRotation > nowMax) {
-                            newRotation = nowMax;
-                        }
-                        else if (newRotation < nowMin) {
-                            newRotation = nowMin;
-                        }
-                    }
-                    this.doRotation.emit(newRotation);
-                }
-                else {
-                    newRotation = 360 - rotationValue;
-                    if (newRotation < nowMin) {
-                        this.doRotation.emit(nowMin);
-                    }
-                    else if (newRotation > nowMax) {
-                        this.doRotation.emit(nowMax);
-                    }
-                    else {
-                        this.doRotation.emit(newRotation);
-                    }
-                }
-            }
-        });
-    }
-}
+import { EventEmitter } from '@angular/core';
+import { RotationDirectionType } from './rotation-direction-type';
+import { RotationObserver } from './rotation-observer';
+export class RotationBehavior {
+    constructor(rotationModel, variableCommunicator, variableStore, signalRAppId) {
+        this.doRotation = new EventEmitter();
+        const rotationObserver = new RotationObserver(rotationModel, variableCommunicator, variableStore, signalRAppId);
+        rotationObserver.rotationValueChanged.subscribe(rotationValue => {
+            if (+rotationModel.rotationDirection === RotationDirectionType.ClockWise) {
+                let newRotation;
+                if (rotationModel.isProportion === true) {
+                    const proportion = (rotationModel.maxAngle - rotationModel.minAngle)
+                        / (rotationModel.maxProportionScale - rotationModel.minProportionScale);
+                    if (rotationModel.isReverseProportion === true) {
+                        if (rotationValue > rotationModel.maxProportionScale) {
+                            newRotation = rotationModel.minAngle;
+                        }
+                        else if (rotationValue < rotationModel.minProportionScale) {
+                            newRotation = rotationModel.maxAngle;
+                        }
+                        else {
+                            newRotation = rotationModel.maxAngle - (rotationValue - rotationModel.minProportionScale) * proportion;
+                        }
+                    }
+                    else {
+                        if (rotationValue > rotationModel.maxProportionScale) {
+                            newRotation = rotationModel.maxAngle;
+                        }
+                        else if (rotationValue < rotationModel.minProportionScale) {
+                            newRotation = rotationModel.minAngle;
+                        }
+                        else {
+                            newRotation = rotationModel.minAngle + (rotationValue - rotationModel.minProportionScale) * proportion;
+                        }
+                    }
+                    this.doRotation.emit(newRotation);
+                }
+                else {
+                    if (rotationValue < rotationModel.minAngle) {
+                        this.doRotation.emit(rotationModel.minAngle);
+                    }
+                    else if (rotationValue > rotationModel.maxAngle) {
+                        this.doRotation.emit(rotationModel.maxAngle);
+                    }
+                    else {
+                        this.doRotation.emit(rotationValue);
+                    }
+                }
+            }
+            else if (+rotationModel.rotationDirection === RotationDirectionType.ReverseClockWise) {
+                let newRotation;
+                const nowMin = 360 - rotationModel.maxAngle;
+                const nowMax = 360 - rotationModel.minAngle;
+                if (rotationModel.isProportion === true) {
+                    const proportion = (nowMax - nowMin) / (rotationModel.maxProportionScale - rotationModel.minProportionScale);
+                    if (rotationModel.isReverseProportion === true) {
+                        if (rotationValue > rotationModel.maxProportionScale) {
+                            newRotation = nowMax;
+                        }
+                        else if (rotationValue < rotationModel.minProportionScale) {
+                            newRotation = nowMin;
+                        }
+                        else {
+                            newRotation = nowMin + (rotationValue - rotationModel.minProportionScale) * proportion;
+                        }
+                    }
+                    else {
+                        if (rotationValue > rotationModel.maxProportionScale) {
+                            newRotation = nowMin;
+                        }
+                        else if (rotationValue < rotationModel.minProportionScale) {
+                            newRotation = nowMax;
+                        }
+                        else {
+                            newRotation = nowMax - (rotationValue - rotationModel.minProportionScale) * proportion;
+                        }
+                        if (newRotation > nowMax) {
+                            newRotation = nowMax;
+                        }
+                        else if (newRotation < nowMin) {
+                            newRotation = nowMin;
+                        }
+                    }
+                    this.doRotation.emit(newRotation);
+                }
+                else {
+                    newRotation = 360 - rotationValue;
+                    if (newRotation < nowMin) {
+                        this.doRotation.emit(nowMin);
+                    }
+                    else if (newRotation > nowMax) {
+                        this.doRotation.emit(nowMax);
+                    }
+                    else {
+                        this.doRotation.emit(newRotation);
+                    }
+                }
+            }
+        });
+    }
+}

package/model/shared/rotation/rotation-direction-type.d.ts

@@ -1,4 +1,4 @@
-export declare enum RotationDirectionType {
-    ClockWise = 0,
-    ReverseClockWise = 1
-}
+export declare enum RotationDirectionType {
+    ClockWise = 0,
+    ReverseClockWise = 1
+}

package/model/shared/rotation/rotation-direction-type.js

@@ -1,5 +1,5 @@
-export var RotationDirectionType;
-(function (RotationDirectionType) {
-    RotationDirectionType[RotationDirectionType["ClockWise"] = 0] = "ClockWise";
-    RotationDirectionType[RotationDirectionType["ReverseClockWise"] = 1] = "ReverseClockWise";
-})(RotationDirectionType || (RotationDirectionType = {}));
+export var RotationDirectionType;
+(function (RotationDirectionType) {
+    RotationDirectionType[RotationDirectionType["ClockWise"] = 0] = "ClockWise";
+    RotationDirectionType[RotationDirectionType["ReverseClockWise"] = 1] = "ReverseClockWise";
+})(RotationDirectionType || (RotationDirectionType = {}));

package/model/shared/rotation/rotation-model.d.ts

@@ -1,14 +1,14 @@
-import { RotationDirectionType } from './rotation-direction-type';
-export interface RotationModel {
-    readonly rotationDirection: RotationDirectionType;
-    readonly variableName: string;
-    readonly minAngle: number;
-    readonly maxAngle: number;
-    readonly isProportion: boolean;
-    readonly minProportionScale: number;
-    readonly maxProportionScale: number;
-    readonly isReverseProportion: boolean;
-    readonly variableGroupName: string;
-    readonly dataSourceCode?: number;
-    readonly variableVersion?: number;
-}
+import { RotationDirectionType } from './rotation-direction-type';
+export interface RotationModel {
+    readonly rotationDirection: RotationDirectionType;
+    readonly variableName: string;
+    readonly minAngle: number;
+    readonly maxAngle: number;
+    readonly isProportion: boolean;
+    readonly minProportionScale: number;
+    readonly maxProportionScale: number;
+    readonly isReverseProportion: boolean;
+    readonly variableGroupName: string;
+    readonly dataSourceCode?: number;
+    readonly variableVersion?: number;
+}

package/model/shared/rotation/rotation-observer-model.d.ts

@@ -1,4 +1,4 @@
-import { EventEmitter } from '@angular/core';
-export interface RotationObserverModel {
-    readonly rotationValueChanged: EventEmitter<number>;
-}
+import { EventEmitter } from '@angular/core';
+export interface RotationObserverModel {
+    readonly rotationValueChanged: EventEmitter<number>;
+}

package/model/shared/rotation/rotation-observer.d.ts

@@ -1,11 +1,11 @@
-import { RotationObserverModel } from './rotation-observer-model';
-import { RotationModel } from './rotation-model';
-import { VariableCommunicator } from '../../../communication';
-import { EventEmitter } from '@angular/core';
-import { VariableStore } from '../../../config';
-export declare class RotationObserver implements RotationObserverModel {
-    private readonly signalRAppId;
-    readonly rotationValueChanged: EventEmitter<number>;
-    private currentValue;
-    constructor(rotationModel: RotationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, signalRAppId: string);
-}
+import { RotationObserverModel } from './rotation-observer-model';
+import { RotationModel } from './rotation-model';
+import { VariableCommunicator } from '../../../communication';
+import { EventEmitter } from '@angular/core';
+import { VariableStore } from '../../../config';
+export declare class RotationObserver implements RotationObserverModel {
+    private readonly signalRAppId;
+    readonly rotationValueChanged: EventEmitter<number>;
+    private currentValue;
+    constructor(rotationModel: RotationModel, variableCommunicator: VariableCommunicator, variableStore: VariableStore, signalRAppId: string);
+}

package/model/shared/rotation/rotation-observer.js

@@ -1,28 +1,28 @@
-import { VariableStateEnum } from '../../../communication';
-import { EventEmitter } from '@angular/core';
-import { VariableUtil } from '../../../utils/variable-util';
-import { VariableDefinition } from '../../../communication/variable/variable-definition';
-export class RotationObserver {
-    constructor(rotationModel, variableCommunicator, variableStore, signalRAppId) {
-        this.signalRAppId = signalRAppId;
-        this.rotationValueChanged = new EventEmitter();
-        if (!rotationModel.variableName) {
-            return;
-        }
-        const variable = new VariableDefinition(rotationModel.variableName, rotationModel.variableGroupName, rotationModel.dataSourceCode, rotationModel.variableVersion);
-        const variableName = VariableUtil.getConvertedVariableName(variableStore, variable);
-        if (!variableName) {
-            return;
-        }
-        variableCommunicator.subscribeVariableState(variableName).subscribe(variableValue => {
-            if (variableValue.state === VariableStateEnum.Normal) {
-                variableCommunicator.openVariable(variableName, this.signalRAppId).subscribe(value => {
-                    if (value.state === VariableStateEnum.DataNormal) {
-                        this.currentValue = value;
-                        this.rotationValueChanged.emit(this.currentValue.value);
-                    }
-                });
-            }
-        });
-    }
-}
+import { VariableStateEnum } from '../../../communication';
+import { EventEmitter } from '@angular/core';
+import { VariableUtil } from '../../../utils/variable-util';
+import { VariableDefinition } from '../../../communication/variable/variable-definition';
+export class RotationObserver {
+    constructor(rotationModel, variableCommunicator, variableStore, signalRAppId) {
+        this.signalRAppId = signalRAppId;
+        this.rotationValueChanged = new EventEmitter();
+        if (!rotationModel.variableName) {
+            return;
+        }
+        const variable = new VariableDefinition(rotationModel.variableName, rotationModel.variableGroupName, rotationModel.dataSourceCode, rotationModel.variableVersion);
+        const variableName = VariableUtil.getConvertedVariableName(variableStore, variable);
+        if (!variableName) {
+            return;
+        }
+        variableCommunicator.subscribeVariableState(variableName).subscribe(variableValue => {
+            if (variableValue.state === VariableStateEnum.Normal) {
+                variableCommunicator.openVariable(variableName, this.signalRAppId).subscribe(value => {
+                    if (value.state === VariableStateEnum.DataNormal) {
+                        this.currentValue = value;
+                        this.rotationValueChanged.emit(this.currentValue.value);
+                    }
+                });
+            }
+        });
+    }
+}

package/model/shared/scale/scale-mark.model.d.ts

@@ -1,6 +1,6 @@
-import { Font } from '../text/font';
-export interface ScaleMarkModel {
-    readonly integerDigits: number;
-    readonly fractionDigits: number;
-    readonly font: Font;
-}
+import { Font } from '../text/font';
+export interface ScaleMarkModel {
+    readonly integerDigits: number;
+    readonly fractionDigits: number;
+    readonly font: Font;
+}

package/model/shared/scale/scale-model.d.ts

@@ -1,20 +1,20 @@
-import { ScaleMarkModel } from './scale-mark.model';
-export interface ScaleModel {
-    /**
-     *主刻度等分数
-     *
-     * @type {number}
-     * @memberof ScaleModel
-     */
-    readonly masterDivider: number;
-    /**
-     *次刻度等分数
-     *
-     * {number}
-     * ScaleModel
-     */
-    readonly slaveDivider: number;
-    readonly stroke: string;
-    readonly showScaleMark: boolean;
-    readonly scaleMarkModel?: ScaleMarkModel;
-}
+import { ScaleMarkModel } from './scale-mark.model';
+export interface ScaleModel {
+    /**
+     *主刻度等分数
+     *
+     * @type {number}
+     * @memberof ScaleModel
+     */
+    readonly masterDivider: number;
+    /**
+     *次刻度等分数
+     *
+     * {number}
+     * ScaleModel
+     */
+    readonly slaveDivider: number;
+    readonly stroke: string;
+    readonly showScaleMark: boolean;
+    readonly scaleMarkModel?: ScaleMarkModel;
+}

package/model/shared/size.model.d.ts

@@ -1,7 +1,7 @@
-export declare class Size {
-    width: number;
-    height: number;
-    constructor(w?: number, h?: number);
-    isReal(): Boolean;
-    toString(): string;
-}
+export declare class Size {
+    width: number;
+    height: number;
+    constructor(w?: number, h?: number);
+    isReal(): Boolean;
+    toString(): string;
+}

package/model/shared/size.model.js

@@ -1,12 +1,12 @@
-export class Size {
-    constructor(w, h) {
-        this.width = w ? w : 0;
-        this.height = h ? h : 0;
-    }
-    isReal() {
-        return isFinite(this.width) && isFinite(this.height);
-    }
-    toString() {
-        return `Size(${this.width} ${this.height})`;
-    }
-}
+export class Size {
+    constructor(w, h) {
+        this.width = w ? w : 0;
+        this.height = h ? h : 0;
+    }
+    isReal() {
+        return isFinite(this.width) && isFinite(this.height);
+    }
+    toString() {
+        return `Size(${this.width} ${this.height})`;
+    }
+}

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

@@ -1 +1 @@
-export * from './state';
+export * from './state';