ngx-hana-nameserver-history-viewer 1.1.3 → 1.1.9-1.beta

package/esm2020/src/nameserver-history-viewer/utils/file-util.mjs

@@ -0,0 +1,154 @@
+import { getTimeFromTimeZone } from './time-util';
+const _DEFAULT_PORT = 'DEFAULT';
+/**
+ * get the default port string (for non-MDC system)
+ */
+export function getDefaultPort() {
+    return _DEFAULT_PORT;
+}
+/**
+ * get abbreviated file name
+ * @param fileName
+ */
+export function getAbbreviatedFileName(fileName) {
+    return fileName == null || fileName.length <= 22 ? fileName : `${fileName.slice(0, 11)}...${fileName.slice(-11)}`;
+}
+/**
+ * get port if empty return default port
+ */
+export function getPort(port) {
+    return port == null || port.length === 0 ? _DEFAULT_PORT : port;
+}
+/**
+ * get all real ports except the default port "default"
+ */
+export function getRealPorts(ports, includeDefault = false) {
+    if (ports == null) {
+        return [];
+    }
+    if (includeDefault) {
+        return ports;
+    }
+    else {
+        return ports.filter(port => port !== _DEFAULT_PORT);
+    }
+}
+/**
+ * get file from <input>
+ * @param inputTarget
+ */
+export function getFileFromInput(inputTarget) {
+    if (inputTarget && inputTarget.files && inputTarget.files.length >= 0) {
+        return inputTarget.files[0];
+    }
+}
+/**
+ * get file from drag and drop
+ */
+export function getFileFromDrop(dragEvent) {
+    return new Promise((resolve, reject) => {
+        if (dragEvent.error) {
+            reject(dragEvent.error);
+        }
+        else {
+            if (dragEvent.file) {
+                resolve(dragEvent.file);
+            }
+        }
+    });
+}
+/**
+ * Check whether the port from file is the same with the selected port.
+ * If the selected port is empty, return true directly. This makes all ports will be selected.
+ * @param portFromFile Port read from file
+ * @param portFromSelection Port from selection.
+ * @param isMDC MDC flag
+ */
+export function isSamePort(portFromFile, portFromSelection, isMDC) {
+    // if it's MDC system, and the port From File is default port, return false
+    if (isMDC && portFromFile === _DEFAULT_PORT) {
+        return false;
+    }
+    // if selected port is empty, return true directly. This makes all ports being selected
+    if (portFromSelection == null || portFromSelection.length === 0) {
+        return true;
+    }
+    return portFromFile === portFromSelection || portFromFile.slice(-2) === portFromSelection.slice(-2);
+}
+/**
+ * As javascript can't get the full path of file, if these two files have same
+ * 1. lastModified, 2. name, 3. size, these two files are considered as the same file
+ */
+export function isSameFile(file1, file2) {
+    if (file1 && file2) {
+        if (file1.lastModified === file2.lastModified && file1.name === file2.name && file1.size === file2.size) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Check whether the provided port is a valid port (3xxxx)
+ */
+export function isValidPort(port) {
+    return port && port.length === 5 && port[0] === '3';
+}
+/**
+ * get next value from current value base on the operator "<" or ">".
+ * Keep using current value until the "nextValue" is not empty.
+ */
+export function calculateValue(lastValue, nextValue) {
+    // if the relative value missed, it's null.
+    // And if it's missed, just use current value from last line.
+    let newValue = lastValue;
+    if (nextValue != null && nextValue.length > 0) {
+        if (nextValue[0] === '<') {
+            newValue = lastValue - parseFloat(nextValue.slice(1));
+        }
+        else if (nextValue[0] === '>') {
+            newValue = lastValue + parseFloat(nextValue.slice(1));
+        }
+        else {
+            newValue = parseFloat(nextValue);
+        }
+    }
+    return newValue;
+}
+/**
+ * get next time value from current time base on the operator "<" or ">".
+ * If nextValue is not "<" or ">", returns converted time base on the timezone
+ */
+export function calculateValue4Time(lastValue, nextValue, timezone) {
+    // if the relative value missed, it's null.
+    // And if it's missed, just use current value from last line.
+    let newValue = lastValue;
+    if (nextValue != null && nextValue.length > 0) {
+        if (nextValue[0] !== '<' && nextValue[0] !== '>') {
+            newValue = getTimeFromTimeZone(parseFloat(nextValue), timezone);
+        }
+        else {
+            newValue = calculateValue(lastValue, nextValue);
+        }
+    }
+    return newValue;
+}
+/**
+ * check whether the data comes from valid nameserver history file
+ */
+export function validateData(data) {
+    return data == null ? false : data.length >= 4 && ['host', 'time'].every(i => data[0].includes(i));
+}
+/**
+ * convert blob to file
+ * @param theBlob
+ * @param fileName
+ */
+export function blobToFile(theBlob, fileName) {
+    const blob = theBlob;
+    // A Blob() is almost a File() - it's just missing the two properties below which we will add
+    blob.lastModifiedDate = new Date();
+    blob.name = fileName;
+    // Cast to a File() type
+    return theBlob;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"file-util.js","sourceRoot":"","sources":["../../../../../src/nameserver-history-viewer/utils/file-util.ts"],"names":[],"mappings":"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","sourcesContent":["import {getTimeFromTimeZone} from './time-util';\r\n\r\nconst _DEFAULT_PORT = 'DEFAULT';\r\n\r\n/**\r\n * get the default port string (for non-MDC system)\r\n */\r\nexport function getDefaultPort(): string {\r\n  return _DEFAULT_PORT;\r\n}\r\n\r\n/**\r\n * get abbreviated file name\r\n * @param fileName\r\n */\r\nexport function getAbbreviatedFileName(fileName: string): string {\r\n  return fileName == null || fileName.length <= 22 ? fileName : `${fileName.slice(0, 11)}...${fileName.slice(-11)}`;\r\n}\r\n\r\n/**\r\n * get port if empty return default port\r\n */\r\nexport function getPort(port: string): string {\r\n  return port == null || port.length === 0 ? _DEFAULT_PORT : port;\r\n}\r\n\r\n/**\r\n * get all real ports except the default port \"default\"\r\n */\r\nexport function getRealPorts(ports: string[], includeDefault: boolean = false): string[] {\r\n  if (ports == null) {\r\n    return [];\r\n  }\r\n  if (includeDefault) {\r\n    return ports;\r\n  } else {\r\n    return ports.filter(port => port !== _DEFAULT_PORT);\r\n  }\r\n}\r\n\r\n/**\r\n * get file from <input>\r\n * @param inputTarget\r\n */\r\nexport function  getFileFromInput(inputTarget: any): File {\r\n  if (inputTarget && inputTarget.files && inputTarget.files.length >= 0) {\r\n    return inputTarget.files[0];\r\n  }\r\n}\r\n\r\n/**\r\n * get file from drag and drop\r\n */\r\nexport function getFileFromDrop(dragEvent: any): Promise<any> {\r\n  return new Promise((resolve, reject) => {\r\n    if (dragEvent.error) {\r\n      reject(dragEvent.error);\r\n    } else {\r\n      if (dragEvent.file) {\r\n        resolve(dragEvent.file);\r\n      }\r\n    }\r\n  });\r\n}\r\n\r\n/**\r\n * Check whether the port from file is the same with the selected port.\r\n * If the selected port is empty, return true directly. This makes all ports will be selected.\r\n * @param portFromFile Port read from file\r\n * @param portFromSelection Port from selection.\r\n * @param isMDC MDC flag\r\n */\r\nexport function isSamePort(portFromFile: string, portFromSelection: string, isMDC: boolean): boolean {\r\n  // if it's MDC system, and the port From File is default port, return false\r\n  if (isMDC && portFromFile === _DEFAULT_PORT) {\r\n    return false;\r\n  }\r\n  // if selected port is empty, return true directly. This makes all ports being selected\r\n  if (portFromSelection == null || portFromSelection.length === 0) {\r\n    return true;\r\n  }\r\n\r\n  return portFromFile === portFromSelection || portFromFile.slice(-2) === portFromSelection.slice(-2);\r\n}\r\n\r\n/**\r\n * As javascript can't get the full path of file, if these two files have same\r\n * 1. lastModified, 2. name, 3. size, these two files are considered as the same file\r\n */\r\nexport function isSameFile(file1: File, file2: File): boolean {\r\n  if (file1 && file2) {\r\n    if (file1.lastModified === file2.lastModified && file1.name === file2.name && file1.size === file2.size) {\r\n      return true;\r\n    }\r\n  }\r\n  return false;\r\n}\r\n\r\n/**\r\n * Check whether the provided port is a valid port (3xxxx)\r\n */\r\nexport function isValidPort(port: string): boolean {\r\n  return port && port.length === 5 && port[0] === '3';\r\n}\r\n\r\n/**\r\n * get next value from current value base on the operator \"<\" or \">\".\r\n * Keep using current value until the \"nextValue\" is not empty.\r\n */\r\nexport function calculateValue(lastValue: number, nextValue: string): number {\r\n  // if the relative value missed, it's null.\r\n  // And if it's missed, just use current value from last line.\r\n  let newValue = lastValue;\r\n  if (nextValue != null && nextValue.length > 0) {\r\n    if (nextValue[0] === '<') {\r\n      newValue = lastValue - parseFloat(nextValue.slice(1));\r\n    } else if (nextValue[0] === '>') {\r\n      newValue = lastValue + parseFloat(nextValue.slice(1));\r\n    } else {\r\n      newValue = parseFloat(nextValue);\r\n    }\r\n  }\r\n  return newValue;\r\n}\r\n\r\n/**\r\n * get next time value from current time base on the operator \"<\" or \">\".\r\n * If nextValue is not \"<\" or \">\", returns converted time base on the timezone\r\n */\r\nexport function calculateValue4Time(lastValue: number, nextValue: string, timezone: string): number {\r\n  // if the relative value missed, it's null.\r\n  // And if it's missed, just use current value from last line.\r\n  let newValue = lastValue;\r\n  if (nextValue != null && nextValue.length > 0) {\r\n    if (nextValue[0] !== '<' && nextValue[0] !== '>') {\r\n      newValue = getTimeFromTimeZone(parseFloat(nextValue), timezone);\r\n    } else {\r\n      newValue = calculateValue(lastValue, nextValue);\r\n    }\r\n  }\r\n  return newValue;\r\n}\r\n\r\n/**\r\n * check whether the data comes from valid nameserver history file\r\n */\r\nexport function validateData(data: string[][]): boolean {\r\n  return data == null ? false : data.length >= 4 && ['host', 'time'].every(i => data[0].includes(i));\r\n}\r\n\r\n/**\r\n * convert blob to file\r\n * @param theBlob\r\n * @param fileName\r\n */\r\nexport function blobToFile (theBlob: Blob, fileName: string): File {\r\n  const blob: any = theBlob;\r\n  // A Blob() is almost a File() - it's just missing the two properties below which we will add\r\n  blob.lastModifiedDate = new Date();\r\n  blob.name = fileName;\r\n\r\n  // Cast to a File() type\r\n  return <File>theBlob;\r\n}\r\n"]}

package/esm2020/src/nameserver-history-viewer/utils/index.mjs

@@ -0,0 +1,5 @@
+export * from './chart-util';
+export * from './file-util';
+export * from './ui-util';
+export * from './time-util';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvbmFtZXNlcnZlci1oaXN0b3J5LXZpZXdlci91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFdBQVcsQ0FBQztBQUMxQixjQUFjLGFBQWEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2hhcnQtdXRpbCc7XHJcbmV4cG9ydCAqIGZyb20gJy4vZmlsZS11dGlsJztcclxuZXhwb3J0ICogZnJvbSAnLi91aS11dGlsJztcclxuZXhwb3J0ICogZnJvbSAnLi90aW1lLXV0aWwnO1xyXG4iXX0=

package/esm2020/src/nameserver-history-viewer/utils/time-util.mjs

@@ -0,0 +1,101 @@
+import { isDevMode } from '@angular/core';
+import { getIgnoredLineNumFromTail } from './ui-util';
+import * as momentImported from 'moment-timezone';
+// workaround for fixing following error when doing packagr: Cannot call a namespace ('moment')
+const moment = momentImported;
+/**
+ * get the time range for all ports
+ */
+function _getTotalTimeRange(time) {
+    if (time) {
+        let startTime = 4102358400000; // 2099/12/31
+        let endTime = 0;
+        Object.keys(time).forEach(port => {
+            if (time[port]) {
+                const timeRangeCurrent = _getTimeRange(time[port]);
+                startTime = startTime > timeRangeCurrent.startTime ? timeRangeCurrent.startTime : startTime;
+                endTime = endTime < timeRangeCurrent.endTime ? timeRangeCurrent.endTime : endTime;
+            }
+        });
+        return { startTime: startTime, endTime: endTime };
+    }
+}
+/**
+ * get the time range (startTime ~ endTime) base on the time (the xScale)
+ */
+function _getTimeRange(time) {
+    const ignoredLineNumFromTail = getIgnoredLineNumFromTail();
+    if (time) {
+        let startTime = 4102358400000; // 2099/12/31
+        let endTime = 0;
+        const len = time.length;
+        if (len > ignoredLineNumFromTail) {
+            startTime = time[0] > startTime ? startTime : time[0];
+            endTime = time[len - ignoredLineNumFromTail - 1] > endTime ? time[len - ignoredLineNumFromTail - 1] : endTime;
+        }
+        return { startTime: startTime, endTime: endTime };
+    }
+}
+/**
+ * get default local time zone
+ */
+export function getDefaultTimezone() {
+    return moment.tz.guess();
+}
+/**
+ * Get time from provided timezone, using this only because chart.js doesn't support timezone.
+ * This function will be removed when chart.js starts to support timezone feature.
+ * @param time time in seconds (Epoch time)
+ * @param timezone timezone string, uses local timezone if this is null.
+ */
+export function getTimeFromTimeZone(time, timezone) {
+    if (timezone == null || timezone.length === 0) {
+        timezone = getDefaultTimezone();
+        console.warn(`getTimeFromTimeZone - Input timezone is null, returning the local (${timezone}) time. `);
+    }
+    const utcOffset = moment.tz.zone(timezone).utcOffset(time * 1000);
+    const currentOffset = moment.tz.zone(getDefaultTimezone()).utcOffset(time * 1000);
+    // convert to utc and then to selected timezone
+    return time + currentOffset * 60 - utcOffset * 60;
+}
+/**
+ * Get time formatted with the provided timezone
+ */
+export function getTimeString(time) {
+    return moment(time).format('YYYY-MM-DD HH:mm:ss');
+}
+/**
+ * Get the time range string by time array, eg: 2018-10-25 10:10:00 ~ 2018-10-25 12:12:00
+ */
+export function getTimeRangeString(time) {
+    let startTimeString = 'N/A';
+    let endTimeString = 'N/A';
+    let timeRange;
+    if (Array.isArray(time)) {
+        timeRange = _getTimeRange(time);
+    }
+    else {
+        timeRange = _getTotalTimeRange(time);
+    }
+    if (timeRange) {
+        if (timeRange.startTime < 4102358400000) {
+            startTimeString = getTimeString(timeRange.startTime);
+        }
+        if (timeRange.endTime > 0) {
+            endTimeString = getTimeString(timeRange.endTime);
+        }
+        return `${startTimeString} ~ ${endTimeString}`;
+    }
+}
+/**
+ * print processed time from the provided beginTime, only works in dev mode
+ */
+export function printProcessedTime(beginTime, step) {
+    if (isDevMode()) {
+        // only do it in dev mode
+        const timeAfter = new Date();
+        const parsingTime = (timeAfter.getTime() - beginTime.getTime()) / 1000;
+        console.log(`${step}, Parsing time: ${parsingTime} seconds`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time-util.js","sourceRoot":"","sources":["../../../../../src/nameserver-history-viewer/utils/time-util.ts"],"names":[],"mappings":"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","sourcesContent":["import { isDevMode } from '@angular/core';\r\nimport { getIgnoredLineNumFromTail } from './ui-util';\r\nimport { ChartContentTime } from '../types';\r\nimport * as momentImported from 'moment-timezone';\r\n\r\n// workaround for fixing following error when doing packagr: Cannot call a namespace ('moment')\r\nconst moment = momentImported;\r\n/**\r\n * get the time range for all ports\r\n */\r\nfunction _getTotalTimeRange(time: ChartContentTime): {startTime: number, endTime: number} {\r\n  if (time) {\r\n    let startTime = 4102358400000; // 2099/12/31\r\n    let endTime = 0;\r\n\r\n    Object.keys(time).forEach(port => {\r\n      if (time[port]) {\r\n        const timeRangeCurrent = _getTimeRange(time[port]);\r\n        startTime = startTime > timeRangeCurrent.startTime ? timeRangeCurrent.startTime : startTime;\r\n        endTime = endTime < timeRangeCurrent.endTime ? timeRangeCurrent.endTime : endTime;\r\n      }\r\n    });\r\n\r\n    return {startTime: startTime, endTime: endTime};\r\n  }\r\n}\r\n\r\n/**\r\n * get the time range (startTime ~ endTime) base on the time (the xScale)\r\n */\r\nfunction _getTimeRange(time: number[]): {startTime: number, endTime: number} {\r\n  const ignoredLineNumFromTail = getIgnoredLineNumFromTail();\r\n  if (time) {\r\n    let startTime = 4102358400000; // 2099/12/31\r\n    let endTime = 0;\r\n\r\n    const len = time.length;\r\n    if (len > ignoredLineNumFromTail) {\r\n      startTime = time[0] > startTime ? startTime : time[0];\r\n      endTime = time[len - ignoredLineNumFromTail - 1] > endTime ? time[len - ignoredLineNumFromTail - 1] : endTime;\r\n    }\r\n\r\n    return {startTime: startTime, endTime: endTime};\r\n  }\r\n}\r\n\r\n/**\r\n * get default local time zone\r\n */\r\nexport function getDefaultTimezone(): string {\r\n  return moment.tz.guess();\r\n}\r\n\r\n/**\r\n * Get time from provided timezone, using this only because chart.js doesn't support timezone.\r\n * This function will be removed when chart.js starts to support timezone feature.\r\n * @param time time in seconds (Epoch time)\r\n * @param timezone timezone string, uses local timezone if this is null.\r\n */\r\nexport function getTimeFromTimeZone (time: number, timezone: string): number {\r\n  if (timezone == null || timezone.length === 0) {\r\n    timezone = getDefaultTimezone();\r\n    console.warn(`getTimeFromTimeZone - Input timezone is null, returning the local (${timezone}) time. `);\r\n  }\r\n  const utcOffset = moment.tz.zone(timezone).utcOffset(time * 1000);\r\n  const currentOffset = moment.tz.zone(getDefaultTimezone()).utcOffset(time * 1000);\r\n  // convert to utc and then to selected timezone\r\n  return time + currentOffset * 60 - utcOffset * 60;\r\n}\r\n\r\n/**\r\n * Get time formatted with the provided timezone\r\n */\r\nexport function getTimeString (time: number): string {\r\n  return moment(time).format('YYYY-MM-DD HH:mm:ss');\r\n}\r\n\r\n/**\r\n * Get the time range string by time array, eg: 2018-10-25 10:10:00 ~ 2018-10-25 12:12:00\r\n */\r\nexport function getTimeRangeString(time: any): string {\r\n  let startTimeString = 'N/A';\r\n  let endTimeString = 'N/A';\r\n  let timeRange;\r\n  if (Array.isArray(time)) {\r\n    timeRange = _getTimeRange(time);\r\n  } else {\r\n    timeRange = _getTotalTimeRange(time);\r\n  }\r\n\r\n  if (timeRange) {\r\n    if (timeRange.startTime < 4102358400000) {\r\n      startTimeString = getTimeString(timeRange.startTime);\r\n    }\r\n\r\n    if (timeRange.endTime > 0) {\r\n      endTimeString = getTimeString(timeRange.endTime);\r\n    }\r\n    return `${startTimeString} ~ ${endTimeString}`;\r\n  }\r\n}\r\n\r\n/**\r\n * print processed time from the provided beginTime, only works in dev mode\r\n */\r\nexport function printProcessedTime(beginTime: Date, step: string): void {\r\n  if (isDevMode()) {\r\n    // only do it in dev mode\r\n    const timeAfter = new Date();\r\n    const parsingTime = (timeAfter.getTime() - beginTime.getTime()) / 1000;\r\n    console.log(`${step}, Parsing time: ${parsingTime} seconds`);\r\n  }\r\n}\r\n"]}

package/esm2020/src/nameserver-history-viewer/utils/ui-util.mjs

@@ -0,0 +1,162 @@
+import { getRealPorts } from './file-util';
+import { UnitType } from '../types';
+/**
+ * For some reason, hana studio will abandon the last line of nameserver history trace file
+ */
+const _IGNORED_LINE_FROM_TAIL = 1;
+/**
+ * None index server ports in name server history,
+ * 01: name server; 02: preprocessor; 04: script server; 05: statistics server / diserver;
+ * 06: web dispatcher; 07: xsengine; 10 compileserver; 11 dpserver; 12 esserver; 29 xscontroller
+ */
+const _NON_INDEX_SERVER_PORTS = ['01', '02', '04', '05', '06', '07', '10', '11', '12', '29'];
+/**
+ * Get the ignored line number from tail (For some reason, hana studio will abandon the last line of nameserver history trace file).
+ */
+export function getIgnoredLineNumFromTail() {
+    return _IGNORED_LINE_FROM_TAIL;
+}
+/**
+ * get the port that needs to be displayed from ports list via the selected port
+ * @param ports overall ports list
+ * @param port the selected port
+ */
+export function getDisplayPort(ports, port) {
+    if (ports != null && ports.length > 0) {
+        if (port == null || port.length === 0) {
+            // if no port is selected
+            if (ports.length === 1) {
+                // not mdc system, will display the only one
+                port = ports[0];
+            }
+            else {
+                // select the first service (not in _NON_INDEX_SERVER_PORTS list)
+                port = getRealPorts(ports).find(p => _NON_INDEX_SERVER_PORTS.indexOf(p.slice(-2)) < 0);
+                if (port == null) {
+                    port = getRealPorts(ports)[0];
+                }
+            }
+        }
+        else {
+            // get real port is port is some thing like 3**03
+            if (port.slice(1, 3) === '**') {
+                port = ports.find(key => key.slice(-2) === port.slice(-2));
+            }
+            else {
+                port = ports.find(key => key === port);
+            }
+        }
+    }
+    else {
+        port = void 0;
+    }
+    return port;
+}
+/**
+ * Generate the ports for ngx-select.
+ * If the provided ports is not null and no port has been selected,
+ * will choose the first item which is not 01 (nameserver) or 07 (xsengine)
+ *
+ */
+export function generatePorts(ports = null, selectedPort = null) {
+    if (ports == null) {
+        return null;
+    }
+    else {
+        // if no selection, choose the first item which is not 01 (nameserver) or 07 (xsengine)
+        if (selectedPort == null || selectedPort === '') {
+            const firstIndexServer = ports.find(p => _NON_INDEX_SERVER_PORTS.indexOf(p.slice(-2)) < 0);
+            selectedPort = firstIndexServer ? firstIndexServer : ports[0];
+        }
+        let index = ports.findIndex(port => port === selectedPort);
+        if (index === -1) {
+            // selection is not exists in the file
+            index = 0;
+        }
+        const newPorts = ports.map(port => ({ id: port, text: port }));
+        newPorts[index].selected = true;
+        return newPorts;
+    }
+}
+/**
+ * get unit factor by unit
+ */
+export function getUnitFactor(unitType) {
+    let unitFactor = 1;
+    switch (unitType) {
+        case UnitType.TypeGB:
+            // BYTE to GB
+            unitFactor = 1024 * 1024 * 1024;
+            break;
+        case UnitType.TypeMB:
+        case UnitType.TypeMBSec:
+            // BYTE to MB
+            unitFactor = 1024 * 1024;
+            break;
+        case UnitType.TypeSecSec:
+            // micro second to second
+            unitFactor = 1000000;
+    }
+    return unitFactor;
+}
+/**
+ * get value by unit (divided by the unit factor).
+ */
+export function getValueByUnit(value, unit) {
+    return (value / getUnitFactor(unit));
+}
+/**
+ * get rounded value: if value >= 10, round to integer; if value < 10, round to at most 2 decimal places
+ */
+export function getRoundedValue(value) {
+    return value >= 10 ? Math.round(value) : Math.round(value * 100) / 100;
+}
+/**
+ * check whether unit is time related.
+ */
+export function isUnitTimeRelated(unit) {
+    return unit === UnitType.TypeMBSec || unit === UnitType.TypeSec || unit === UnitType.TypeSecSec;
+}
+/**
+ * calculate YScale base on the provided value
+ */
+export function calculateYScale(value) {
+    // round up to next 2,5,10,20,50,100,...
+    if (value <= 0) {
+        return 100;
+    }
+    const scale = Math.pow(10, Math.floor(Math.log10(value)));
+    if (scale >= value) {
+        return scale;
+    }
+    if (2 * scale >= value) {
+        return 2 * scale;
+    }
+    if (5 * scale >= value) {
+        return 5 * scale;
+    }
+    return 10 * scale;
+}
+export function isEmptyData(data) {
+    if (data) {
+        return Object.keys(data).findIndex(port => {
+            if (port != null && data[port]) {
+                return data[port].findIndex(row => row && row.length > 0) >= 0;
+            }
+            return false;
+        }) < 0;
+    }
+    return true;
+}
+export function sleep(time) {
+    return new Promise((resolve) => setTimeout(resolve, time));
+}
+export function setChartHeight(nsAll, nsContent) {
+    // const item1 = (document.getElementsByClassName('nameserver-history-all') as HTMLCollectionOf<HTMLElement>)[0];
+    // const item2 = (document.getElementsByClassName('nameserver-history-content') as HTMLCollectionOf<HTMLElement>)[0];
+    if (nsAll && nsContent) {
+        const chartHeight = nsAll.offsetWidth * 0.75 / 2 + 10;
+        nsContent.style.height = `${chartHeight}px`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui-util.js","sourceRoot":"","sources":["../../../../../src/nameserver-history-viewer/utils/ui-util.ts"],"names":[],"mappings":"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","sourcesContent":["import { getRealPorts } from './file-util';\r\nimport {UnitType, Port, ChartContentData} from '../types';\r\n\r\n/**\r\n * For some reason, hana studio will abandon the last line of nameserver history trace file\r\n */\r\nconst _IGNORED_LINE_FROM_TAIL = 1;\r\n\r\n/**\r\n * None index server ports in name server history,\r\n * 01: name server; 02: preprocessor; 04: script server; 05: statistics server / diserver;\r\n * 06: web dispatcher; 07: xsengine; 10 compileserver; 11 dpserver; 12 esserver; 29 xscontroller\r\n */\r\nconst _NON_INDEX_SERVER_PORTS = ['01', '02', '04', '05', '06', '07', '10', '11', '12', '29'];\r\n\r\n/**\r\n * Get the ignored line number from tail (For some reason, hana studio will abandon the last line of nameserver history trace file).\r\n */\r\nexport function getIgnoredLineNumFromTail() {\r\n    return _IGNORED_LINE_FROM_TAIL;\r\n}\r\n\r\n/**\r\n * get the port that needs to be displayed from ports list via the selected port\r\n * @param ports overall ports list\r\n * @param port the selected port\r\n */\r\nexport function getDisplayPort(ports: string[], port: string): string {\r\n  if (ports != null && ports.length > 0) {\r\n    if (port == null || port.length === 0) {\r\n      // if no port is selected\r\n      if (ports.length === 1) {\r\n        // not mdc system, will display the only one\r\n        port = ports[0];\r\n      } else {\r\n        // select the first service (not in _NON_INDEX_SERVER_PORTS list)\r\n        port = getRealPorts(ports).find(p => _NON_INDEX_SERVER_PORTS.indexOf(p.slice(-2)) < 0);\r\n        if (port == null) {\r\n          port = getRealPorts(ports)[0];\r\n        }\r\n      }\r\n    } else {\r\n      // get real port is port is some thing like 3**03\r\n      if (port.slice(1, 3) === '**') {\r\n        port = ports.find(key => key.slice(-2) === port.slice(-2));\r\n      } else {\r\n        port = ports.find(key => key === port);\r\n      }\r\n    }\r\n  } else {\r\n    port = void 0;\r\n  }\r\n  return port;\r\n}\r\n\r\n/**\r\n * Generate the ports for ngx-select.\r\n * If the provided ports is not null and no port has been selected,\r\n * will choose the first item which is not 01 (nameserver) or 07 (xsengine)\r\n *\r\n */\r\nexport function generatePorts(ports: string[] = null, selectedPort: string = null): Port[] {\r\n  if (ports == null) {\r\n    return null;\r\n  } else {\r\n    // if no selection, choose the first item which is not 01 (nameserver) or 07 (xsengine)\r\n    if (selectedPort == null || selectedPort === '') {\r\n      const firstIndexServer = ports.find(p => _NON_INDEX_SERVER_PORTS.indexOf(p.slice(-2)) < 0);\r\n      selectedPort = firstIndexServer ? firstIndexServer : ports[0];\r\n    }\r\n\r\n    let index = ports.findIndex(port => port === selectedPort);\r\n    if (index === -1) {\r\n      // selection is not exists in the file\r\n      index = 0;\r\n    }\r\n    const newPorts: Port[] = ports.map(port => ({id: port, text: port}));\r\n    newPorts[index].selected = true;\r\n    return newPorts;\r\n  }\r\n}\r\n\r\n/**\r\n * get unit factor by unit\r\n */\r\nexport function getUnitFactor(unitType: UnitType): number {\r\n  let unitFactor = 1;\r\n  switch (unitType) {\r\n    case UnitType.TypeGB:\r\n      // BYTE to GB\r\n      unitFactor = 1024 * 1024 * 1024;\r\n      break;\r\n    case UnitType.TypeMB:\r\n    case UnitType.TypeMBSec:\r\n      // BYTE to MB\r\n      unitFactor = 1024 * 1024;\r\n      break;\r\n    case UnitType.TypeSecSec:\r\n      // micro second to second\r\n      unitFactor = 1000000;\r\n  }\r\n  return unitFactor;\r\n}\r\n/**\r\n * get value by unit (divided by the unit factor).\r\n */\r\nexport function getValueByUnit(value: number, unit: UnitType): number {\r\n  return (value / getUnitFactor(unit));\r\n}\r\n\r\n/**\r\n * get rounded value: if value >= 10, round to integer; if value < 10, round to at most 2 decimal places\r\n */\r\nexport function getRoundedValue(value: number): number {\r\n  return value >= 10 ? Math.round (value) : Math.round(value * 100) / 100;\r\n}\r\n\r\n/**\r\n * check whether unit is time related.\r\n */\r\nexport function isUnitTimeRelated (unit: UnitType): boolean {\r\n  return unit === UnitType.TypeMBSec || unit === UnitType.TypeSec || unit === UnitType.TypeSecSec;\r\n}\r\n\r\n/**\r\n * calculate YScale base on the provided value\r\n */\r\nexport function calculateYScale(value: number): number {\r\n  // round up to next 2,5,10,20,50,100,...\r\n  if (value <= 0) {\r\n    return 100;\r\n  }\r\n  const scale = Math.pow( 10, Math.floor(Math.log10(value)));\r\n  if (scale >= value) {\r\n    return scale;\r\n  }\r\n  if (2 * scale >= value) {\r\n    return 2 * scale;\r\n  }\r\n  if ( 5 * scale >= value) {\r\n    return 5 * scale;\r\n  }\r\n\r\n  return 10 * scale;\r\n}\r\n\r\nexport function isEmptyData(data: ChartContentData): boolean {\r\n  if (data) {\r\n    return Object.keys(data).findIndex(port => {\r\n      if (port != null && data[port]) {\r\n        return data[port].findIndex(row => row && row.length > 0) >= 0;\r\n      }\r\n      return false;\r\n    }) < 0;\r\n  }\r\n  return true;\r\n}\r\n\r\nexport function sleep (time: number): Promise<any> {\r\n  return new Promise((resolve) => setTimeout(resolve, time));\r\n}\r\n\r\nexport function setChartHeight(nsAll, nsContent): void {\r\n  // const item1 = (document.getElementsByClassName('nameserver-history-all') as HTMLCollectionOf<HTMLElement>)[0];\r\n  // const item2 = (document.getElementsByClassName('nameserver-history-content') as HTMLCollectionOf<HTMLElement>)[0];\r\n  if (nsAll && nsContent) {\r\n    const chartHeight = nsAll.offsetWidth * 0.75 / 2 + 10;\r\n    nsContent.style.height = `${chartHeight}px`;\r\n  }\r\n}\r\n\r\n"]}