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

package/utils/data-type/fcloud-data-type.service.js

@@ -0,0 +1,203 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Injectable, Inject } from '@angular/core';
+import { LOCALIZATION } from '../../localization';
+import { FCloudDataType } from '../../model/shared/data-type/fcloud-data-Type';
+let FCloudDataTypeService = class FCloudDataTypeService {
+    constructor(localization) {
+        this.localization = localization;
+        this.defaultIntegerDigits = 4;
+        this.defaultFractionDigits = 0;
+        this.dataTypeList = new Map();
+        // 1, 'Int32'
+        // 2, 'Float'
+        // 4, 'Bool'
+        // 8, 'String'
+        // 90, 'Binary'
+        // 99, 'Hex'
+    }
+    getValueType(id) {
+        switch (id) {
+            case FCloudDataType.Binary:
+                return this.localization.binaryType;
+            case FCloudDataType.Int32:
+            case FCloudDataType.Float:
+                return this.localization.decimalType;
+            case FCloudDataType.Hex:
+                return this.localization.hexadecimalType;
+            case FCloudDataType.String:
+                return this.localization.stringType;
+        }
+    }
+    getValuePattern(id) {
+        switch (id) {
+            case FCloudDataType.Binary:
+                return '^[01]+$';
+            case FCloudDataType.Int32:
+            case FCloudDataType.Float:
+                return '^[+-]?[0-9]*(\\.[0-9]*)?$';
+            case FCloudDataType.Hex:
+                return '^[0-9a-fA-F]+$';
+        }
+    }
+    isHexType(id) {
+        return id === FCloudDataType.Hex;
+    }
+    isBinaryType(id) {
+        return id === FCloudDataType.Binary;
+    }
+    isHexOrBinaryType(id) {
+        return id === FCloudDataType.Binary || id === FCloudDataType.Hex;
+    }
+    isFloat(id) {
+        return id === FCloudDataType.Float;
+    }
+    /**
+     * 获取数据型号最大长度
+     * @param id
+     */
+    getValueMaxLength(id) {
+        switch (id) {
+            case FCloudDataType.Int32: // Int32
+                return 10;
+            case FCloudDataType.Float:
+                return 11;
+            case FCloudDataType.Binary: // Binary
+                return 32;
+            case FCloudDataType.Hex: // Hex
+                return 8;
+            default:
+                return 0;
+        }
+    }
+    /**
+     * 是否支持小数位
+     * @param id
+     */
+    isSupportFractionDigit(id) {
+        return id !== FCloudDataType.Bool && id !== FCloudDataType.String && id !== FCloudDataType.Binary && id !== FCloudDataType.Hex;
+    }
+    /**
+    * 是否为有符号数
+    * @param id
+    */
+    isSignedType(id) {
+        return id === FCloudDataType.Int32 || id === FCloudDataType.Float;
+    }
+    /**
+     * 是否支持数值运算
+     * @param id
+     */
+    isSupportNumericalOperation(id) {
+        return id !== FCloudDataType.Bool && id !== FCloudDataType.Binary && id !== FCloudDataType.Hex && id !== FCloudDataType.String;
+    }
+    /**
+    * 数据转换成10进制
+    * @param value
+    * @param id
+    */
+    formatToDecimal(value, id) {
+        if (this.isBinaryType(id)) {
+            return parseInt(value, 2);
+        }
+        if (this.isHexType(id)) {
+            return parseInt(value, 16);
+        }
+        return value;
+    }
+    /**
+       * 获取数据型号最小值
+       * @param id
+       * @param? integerDigits
+       * @param? fractionDigits
+       */
+    getMinValue(id, integerDigits, fractionDigits) {
+        let minValue;
+        switch (id) {
+            case FCloudDataType.Binary:
+            case FCloudDataType.Hex:
+                minValue = 0;
+                break;
+            case FCloudDataType.Int32:
+                minValue = -2147483648;
+                break;
+            case FCloudDataType.Float:
+                minValue = -1000000000;
+                break;
+        }
+        if (integerDigits) {
+            let digitsLength = integerDigits;
+            if (fractionDigits) {
+                digitsLength = digitsLength + fractionDigits;
+            }
+            if (digitsLength) {
+                if (minValue.toString().length - 1 > digitsLength) {
+                    minValue = -this.getFillNine(digitsLength);
+                }
+            }
+            if (this.isFloat(id) && fractionDigits) {
+                minValue = minValue / Math.pow(10, fractionDigits);
+            }
+        }
+        return minValue;
+    }
+    /**
+       * 获取数据型号最大值
+       * @param id
+       * @param? integerDigits
+       * @param? fractionDigits
+       */
+    getMaxValue(id, integerDigits, fractionDigits) {
+        let maxValue;
+        switch (id) {
+            case FCloudDataType.Binary:
+            case FCloudDataType.Hex:
+                maxValue = 4294967295;
+                break;
+            case FCloudDataType.Int32:
+                maxValue = 2147483647;
+                break;
+            case FCloudDataType.Float:
+                maxValue = 1000000000;
+                break;
+        }
+        if (integerDigits) {
+            let digitsLength = integerDigits;
+            if (fractionDigits) {
+                digitsLength = digitsLength + fractionDigits;
+            }
+            if (digitsLength) {
+                if (maxValue.toString().length > digitsLength) {
+                    maxValue = this.getFillNine(digitsLength);
+                }
+            }
+            if (this.isFloat(id) && fractionDigits) {
+                maxValue = maxValue / Math.pow(10, fractionDigits);
+            }
+        }
+        return maxValue;
+    }
+    getFillNine(num) {
+        let text = '9';
+        for (let i = 1; i < num; i++) {
+            text = `9${text}`;
+        }
+        return text;
+    }
+};
+FCloudDataTypeService = __decorate([
+    Injectable(),
+    __param(0, Inject(LOCALIZATION)),
+    __metadata("design:paramtypes", [Object])
+], FCloudDataTypeService);
+export { FCloudDataTypeService };

package/utils/data-type/fcloud-data-type.service.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"FCloudDataTypeService":{"__symbolic":"class","decorators":[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Injectable","line":4,"character":1}}],"members":{"__ctor__":[{"__symbolic":"constructor","parameterDecorators":[[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Inject","line":11,"character":17},"arguments":[{"__symbolic":"reference","module":"../../localization","name":"LOCALIZATION","line":11,"character":24}]}]],"parameters":[{"__symbolic":"reference","module":"../../localization","name":"Localization","line":11,"character":60}]}],"getValueType":[{"__symbolic":"method"}],"getValuePattern":[{"__symbolic":"method"}],"isHexType":[{"__symbolic":"method"}],"isBinaryType":[{"__symbolic":"method"}],"isHexOrBinaryType":[{"__symbolic":"method"}],"isFloat":[{"__symbolic":"method"}],"getValueMaxLength":[{"__symbolic":"method"}],"isSupportFractionDigit":[{"__symbolic":"method"}],"isSignedType":[{"__symbolic":"method"}],"isSupportNumericalOperation":[{"__symbolic":"method"}],"formatToDecimal":[{"__symbolic":"method"}],"getMinValue":[{"__symbolic":"method"}],"getMaxValue":[{"__symbolic":"method"}],"getFillNine":[{"__symbolic":"method"}]}}}}]

package/utils/fraction-digit.service.d.ts

@@ -0,0 +1,41 @@
+export declare class FractionDigitService {
+    private readonly zeroText;
+    /**
+     * 左补齐字符串
+     * number  要处理的数字
+     * fillLength 要补齐的长度
+     * char 要补齐的字符
+     */
+    private padLeft;
+    /**
+     * 右补齐字符串
+     * @param number  要处理的数字
+     * @param fillLength 要补齐的长度
+     * @param char  要补齐的字符
+     */
+    private padRight;
+    /**
+     * 左移小数点位置（用于数学计算，相当于除以Math.pow(10,scale)）
+     * @param fractionDigits 要移位的刻度
+     * @return
+     */
+    private movePointLeft;
+    /**
+     * 右移小数点位置（用于数学计算，相当于乘以Math.pow(10,scale)）
+     * @param number  要处理的数字
+     * @param fractionDigits 要移位的刻度
+     */
+    private movePointRight;
+    /**
+     * 移动小数点位置（用于数学计算，相当于（乘以/除以）Math.pow(10,scale)）
+     * @param number  要处理的数字
+     * @param fractionDigits  要移位的刻度（正数表示向右移；负数表示向左移动；0返回原值）
+     */
+    movePoint(number: any, fractionDigits: any): string;
+    /**
+     * 按照指定的小数位，对数字进行四舍五入计算
+     * @param number 要处理的数字
+     * @param fractionDigits 指定的小数位
+     */
+    roundingToFixedFractionDigits(number: any, fractionDigits: number): string;
+}

package/utils/fraction-digit.service.js

@@ -0,0 +1,133 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable } from '@angular/core';
+let FractionDigitService = class FractionDigitService {
+    constructor() {
+        this.zeroText = '0';
+    }
+    /**
+     * 左补齐字符串
+     * number  要处理的数字
+     * fillLength 要补齐的长度
+     * char 要补齐的字符
+     */
+    padLeft(number, fillLength, char) {
+        let result = String(number);
+        char = char ? char : this.zeroText; // 默认补0
+        let currentLength = result.length;
+        while (currentLength < fillLength) {
+            result = char + result;
+            currentLength++;
+        }
+        return result.toString();
+    }
+    /**
+     * 右补齐字符串
+     * @param number  要处理的数字
+     * @param fillLength 要补齐的长度
+     * @param char  要补齐的字符
+     */
+    padRight(number, fillLength, char) {
+        let result = String(number);
+        char = char ? char : this.zeroText; // 默认补0
+        let currentLength = result.length;
+        while (currentLength < fillLength) {
+            result = result + char;
+            currentLength++;
+        }
+        return result.toString();
+    }
+    /**
+     * 左移小数点位置（用于数学计算，相当于除以Math.pow(10,scale)）
+     * @param fractionDigits 要移位的刻度
+     * @return
+     */
+    movePointLeft(number, fractionDigits) {
+        if (fractionDigits <= 0) {
+            return number;
+        }
+        const numberText = String(number);
+        const decimalParts = numberText.split('.');
+        let intergerPart = decimalParts[0] ? decimalParts[0] : '';
+        const fractionPart = decimalParts[1] ? decimalParts[1] : '';
+        let fractionPointText = '.';
+        let minusText = '';
+        if (intergerPart.slice(0, 1) === '-') {
+            intergerPart = intergerPart.slice(1);
+            minusText = '-';
+        }
+        if (intergerPart.length <= fractionDigits) {
+            fractionPointText = '0.';
+            intergerPart = this.padLeft(intergerPart, fractionDigits, '0');
+        }
+        return minusText +
+            intergerPart.slice(0, -fractionDigits) +
+            fractionPointText +
+            intergerPart.slice(-fractionDigits) +
+            fractionPart;
+    }
+    /**
+     * 右移小数点位置（用于数学计算，相当于乘以Math.pow(10,scale)）
+     * @param number  要处理的数字
+     * @param fractionDigits 要移位的刻度
+     */
+    movePointRight(number, fractionDigits) {
+        if (fractionDigits <= 0) {
+            return number;
+        }
+        // eslint-disable-next-line no-new-wrappers
+        const numberText = new String(number);
+        const decimalParts = numberText.split('.');
+        const intergerPart = decimalParts[0] ? decimalParts[0] : '';
+        let fractionPart = decimalParts[1] ? decimalParts[1] : '';
+        let fractionPointText = '.';
+        if (fractionPart.length <= fractionDigits) {
+            fractionPointText = '';
+            fractionPart = this.padRight(fractionPart, fractionDigits, '0');
+        }
+        return intergerPart +
+            fractionPart.slice(0, fractionDigits) +
+            fractionPointText +
+            fractionPart.slice(fractionDigits, fractionPart.length);
+    }
+    /**
+     * 移动小数点位置（用于数学计算，相当于（乘以/除以）Math.pow(10,scale)）
+     * @param number  要处理的数字
+     * @param fractionDigits  要移位的刻度（正数表示向右移；负数表示向左移动；0返回原值）
+     */
+    movePoint(number, fractionDigits) {
+        return fractionDigits >= 0
+            ? this.movePointRight(number, fractionDigits)
+            : this.movePointLeft(number, -fractionDigits);
+    }
+    /**
+     * 按照指定的小数位，对数字进行四舍五入计算
+     * @param number 要处理的数字
+     * @param fractionDigits 指定的小数位
+     */
+    roundingToFixedFractionDigits(number, fractionDigits) {
+        const numberText = String(number);
+        const fractionPointIndex = numberText.indexOf('.') + 1;
+        const currentFractionDigits = numberText.length - fractionPointIndex;
+        if (fractionPointIndex >= 1 && currentFractionDigits > fractionDigits) {
+            let result = +this.movePoint(numberText, fractionDigits);
+            const roundingNumber = Number(numberText.substr(fractionPointIndex + fractionDigits, 1));
+            if (roundingNumber >= 5 && number >= 0 || roundingNumber < 5 && number < 0) {
+                result = Math.ceil(result);
+            }
+            else {
+                result = Math.floor(result);
+            }
+            return this.movePoint(result, -fractionDigits);
+        }
+        return Number(number).toFixed(fractionDigits);
+    }
+};
+FractionDigitService = __decorate([
+    Injectable()
+], FractionDigitService);
+export { FractionDigitService };

package/utils/fraction-digit.service.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"FractionDigitService":{"__symbolic":"class","decorators":[{"__symbolic":"call","expression":{"__symbolic":"reference","module":"@angular/core","name":"Injectable","line":2,"character":1}}],"members":{"padLeft":[{"__symbolic":"method"}],"padRight":[{"__symbolic":"method"}],"movePointLeft":[{"__symbolic":"method"}],"movePointRight":[{"__symbolic":"method"}],"movePoint":[{"__symbolic":"method"}],"roundingToFixedFractionDigits":[{"__symbolic":"method"}]}}}}]

package/utils/graph-util.d.ts

@@ -0,0 +1,5 @@
+import { GraphSetting } from '../model';
+import { GraphExtendedStyle } from '../shared';
+export declare class GraphUtil {
+    static getExtendedStyle(graphSetting: GraphSetting, stateIndex: number): GraphExtendedStyle | undefined;
+}

package/utils/graph-util.js

@@ -0,0 +1,19 @@
+export class GraphUtil {
+    static getExtendedStyle(graphSetting, stateIndex) {
+        if (stateIndex < 0) {
+            throw new Error('stateIndex can not less than zero.');
+        }
+        let result;
+        if (graphSetting.styles != null) {
+            result = graphSetting.styles.find(style => {
+                if (style.version == null) {
+                    return style.state != null && +style.state === stateIndex;
+                }
+                {
+                    return style.stateIndex === stateIndex;
+                }
+            });
+        }
+        return result;
+    }
+}

package/utils/graph-util.metadata.json

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

package/utils/guid.d.ts

@@ -0,0 +1,6 @@
+export declare class Guid {
+    readonly guid: string;
+    static newGuid(): Guid;
+    constructor(guid: string);
+    toString(format?: string): string;
+}

package/utils/guid.js

@@ -0,0 +1,27 @@
+export class Guid {
+    constructor(guid) {
+        this.guid = guid;
+    }
+    static newGuid() {
+        let result;
+        let i;
+        let j;
+        result = '';
+        for (j = 0; j < 32; j++) {
+            if (j === 8 || j === 12 || j === 16 || j === 20) {
+                result = result + '-';
+            }
+            i = Math.floor(Math.random() * 16).toString(16).toUpperCase();
+            result = result + i;
+        }
+        return new Guid(result);
+    }
+    toString(format) {
+        if (format && 'n' === format.toLowerCase()) {
+            return this.guid.replace(/-/g, '');
+        }
+        else {
+            return this.guid;
+        }
+    }
+}

package/utils/guid.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"Guid":{"__symbolic":"class","members":{"__ctor__":[{"__symbolic":"constructor","parameters":[{"__symbolic":"reference","name":"string"}]}],"toString":[{"__symbolic":"method"}]}}}}]

package/utils/index.d.ts

@@ -0,0 +1,7 @@
+export { AccessPermissionService } from './access-permission.service';
+export { GraphUtil } from './graph-util';
+export { FBoxDataTypeService } from './data-type/fbox-data-type.service';
+export { FCloudDataTypeService } from './data-type/fcloud-data-type.service';
+export { DataTypeService } from './data-type/data-type.service';
+export { FractionDigitService } from './fraction-digit.service';
+export { NumericalOperationService } from './numerical-operation.service';

package/utils/index.js

@@ -0,0 +1,7 @@
+export { AccessPermissionService } from './access-permission.service';
+export { GraphUtil } from './graph-util';
+export { FBoxDataTypeService } from './data-type/fbox-data-type.service';
+export { FCloudDataTypeService } from './data-type/fcloud-data-type.service';
+export { DataTypeService } from './data-type/data-type.service';
+export { FractionDigitService } from './fraction-digit.service';
+export { NumericalOperationService } from './numerical-operation.service';

package/utils/index.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{},"exports":[{"from":"./access-permission.service","export":["AccessPermissionService"]},{"from":"./graph-util","export":["GraphUtil"]},{"from":"./data-type/fbox-data-type.service","export":["FBoxDataTypeService"]},{"from":"./data-type/fcloud-data-type.service","export":["FCloudDataTypeService"]},{"from":"./data-type/data-type.service","export":["DataTypeService"]},{"from":"./fraction-digit.service","export":["FractionDigitService"]},{"from":"./numerical-operation.service","export":["NumericalOperationService"]}]}]

package/utils/numerical-operation-type.d.ts

@@ -0,0 +1,4 @@
+export declare enum NumericalOperationType {
+    ProportionalConversion = 2,
+    Zoom = 4
+}

package/utils/numerical-operation-type.js

@@ -0,0 +1,5 @@
+export var NumericalOperationType;
+(function (NumericalOperationType) {
+    NumericalOperationType[NumericalOperationType["ProportionalConversion"] = 2] = "ProportionalConversion";
+    NumericalOperationType[NumericalOperationType["Zoom"] = 4] = "Zoom";
+})(NumericalOperationType || (NumericalOperationType = {}));

package/utils/numerical-operation-type.metadata.json

@@ -0,0 +1 @@
+[{"__symbolic":"module","version":4,"metadata":{"NumericalOperationType":{"ProportionalConversion":2,"Zoom":4}}}]

package/utils/numerical-operation.service.d.ts

@@ -0,0 +1,17 @@
+import { NumericalOperation } from '../model/numerical-display/numerical-operation';
+import { DataTypeService } from './data-type/data-type.service';
+import { NumericalDisplay } from '../model';
+export declare class NumericalOperationService {
+    private readonly dataTypeService;
+    constructor(dataTypeService: DataTypeService);
+    getNumericalOperationedValue(model: any, value: any, fractionDigits: number): any;
+    getNumericalOperations(model: NumericalDisplay): NumericalOperation;
+    getWriteValue(version: number, value: string, option: NumericalOperation, dataType: number, fractionDigits: number): string;
+    getWriteMaxValue(numericalUpperLimit: number, option: NumericalOperation): number;
+    getWriteMinValue(numericalLowerLimit: number, option: NumericalOperation): number;
+    toInteger(floatNum: number): {
+        times: number;
+        num: number;
+    };
+    isInteger(obj: any): boolean;
+}