@miso.ai/server-commons 0.5.4-beta.2 → 0.5.4-beta.4

package/package.json

@@ -16,5 +16,5 @@
     "js-yaml": "^4.1.0",
     "toml": "^3.0.0"
   },
-  "version": "0.5.4-beta.2"
+  "version": "0.5.4-beta.4"
 }

package/src/async.js

@@ -0,0 +1,4 @@
+export async function delay(duration) {
+  // TODO: can accept abort singal
+  return new Promise((resolve) => setTimeout(resolve, duration));
+}

package/src/index.js

@@ -1,6 +1,12 @@
 export * from './object.js';
-export * as stream from './stream.js';
+export * from './string.js';
 export * from './date.js';
 export * from './file.js';
 export * from './config.js';
+export * from './async.js';
+
+export * as stream from './stream.js';
+export * as log from './log.js';
+
 export { default as TaskQueue } from './task-queue.js';
+export { default as Resolution } from './resolution.js';

package/src/log.js

@@ -0,0 +1,96 @@
+import { padLeft, padRight } from './string.js';
+
+export const FATAL = 'fatal';
+export const ERROR = 'error';
+export const WARNING = 'warning';
+export const INFO = 'info';
+export const DEBUG = 'debug';
+
+const LEVEL_VALUES = {
+  [FATAL]: 2,
+  [ERROR]: 4,
+  [WARNING]: 6,
+  [INFO]: 8,
+  [DEBUG]: 50,
+};
+const FALLBACK_LEVEL_VALUE = 40;
+
+export const LEVELS = Object.keys(LEVEL_VALUES);
+
+LEVELS.sort(compareLevel);
+
+export function reachesThreshold(level, threshold) {
+  if (!LEVEL_VALUES[threshold]) {
+    throw new Error(`Unrecognized log level: ${threshold}`);
+  }
+  if (!level) {
+    throw new Error(`Level is absent: ${level}`);
+  }
+  return compareLevel(level, threshold) <= 0;
+}
+
+export function isError(level) {
+  return reachesThreshold(level, ERROR);
+}
+
+function compareLevel(a, b) {
+  return (LEVEL_VALUES[a] || FALLBACK_LEVEL_VALUE) - (LEVEL_VALUES[b] || FALLBACK_LEVEL_VALUE);
+}
+
+export function formatDuration(value) {
+  if (typeof value !== 'number') {
+    throw new Error(`Value must be a number: ${value}`);
+  }
+  value = Math.floor(value);
+  const ms = padLeft(`${value % 60000}`, 5, '0');
+  let min = '00';
+  let hour = '00';
+  if (value >= 60000) {
+    value = Math.floor(value / 60000);
+    min = padLeft(`${value % 60}`, 2, '0');
+    if (value >= 60) {
+      hour = padLeft(Math.floor(value / 60), 2, '0');
+    }
+  }
+  return `${hour}:${min}:${ms.substring(0, 2)}.${ms.substring(2, 5)}`;
+}
+
+export function formatBytes(value) {
+  let i = 0;
+  for (; i < 4; i++) {
+    if (value < 1024) {
+      break;
+    }
+    value /= 1024;
+  }
+  return `${Math.floor(value * 100) / 100} ${UNITS[i]}`;
+}
+
+const UNITS = ['B', 'KB', 'MB', 'GB', 'TB'];
+
+export function formatTable(rows, { columnPadding: columnSpacing = 3 } = {}) {
+  const maxLens = [];
+  for (const cells of rows) {
+    for (let j = 0, len = cells.length; j < len; j++) {
+      const len = `${cells[j]}`.length;
+      if (!maxLens[j] || maxLens[j] < len) {
+        maxLens[j] = len;
+      }
+    }
+  }
+  const colSpc = ' '.repeat(columnSpacing);
+  let str = '';
+  for (let i = 0, len = rows.length; i < len; i++) {
+    if (i > 0) {
+      str += '\n';
+    }
+    const cells = rows[i];
+    for (let j = 0, len = cells.length; j < len; j++) {
+      if (j > 0) {
+        str += colSpc;
+      }
+      str += padRight(`${cells[j]}`, maxLens[j], ' ');
+    }
+  }
+  return str;
+}

package/src/resolution.js

@@ -0,0 +1,12 @@
+export default class Resolution {
+
+  constructor() {
+    const self = this;
+    self.promise = new Promise((resolve, reject) => {
+      self.resolve = resolve;
+      self.reject = reject;
+    });
+    Object.freeze(this);
+  }
+
+}

package/src/stream.js

@@ -12,12 +12,22 @@ export function parse() {
 export function stringify() {
   return new Transform({
     transform(chunk, _, callback) {
-      callback(null, JSON.stringify(chunk) + '\n');
+      try {
+        callback(null, JSON.stringify(chunk) + '\n');
+      } catch(e) {
+        callback(null, `${chunk}` + '\n');
+      }
     },
     writableObjectMode: true,
   });
 }
 
+export async function pipeline(...streams) {
+  return new Promise((resolve, reject) =>
+    _pipeline(...streams, err => err ? reject(err) : resolve())
+  );
+}
+
 export async function pipelineToStdout(...streams) {
   return new Promise((resolve, reject) => 
     _pipeline(...streams, err => err ? reject(err) : resolve())

package/src/string.js

@@ -0,0 +1,32 @@
+// From:
+// https://github.com/jonschlinkert/pad-right
+
+const DEFAULT_PAD = ' ';
+const DEFAULT_PAD_5 = DEFAULT_PAD.repeat(5);
+const DEFAULT_PAD_25 = DEFAULT_PAD.repeat(25);
+
+function pad(left, val, num, str) {
+  const diff = num - val.length;
+  if (diff <= 0) {
+    return val;
+  }
+  const padding = buildPadding(diff, str);
+  return left ? padding + val : val + padding;
+}
+
+function buildPadding(count, str) {
+  // Breakpoints based on benchmarks to use the fastest approach
+  // for the given number of zeros
+  return str ? str.repeat(count) :
+    count <= 5 ? DEFAULT_PAD_5.slice(0, count) :
+    count <= 25 ? DEFAULT_PAD_25.slice(0, count) :
+    DEFAULT_PAD.repeat(count);
+}
+
+export function padLeft(val, num, str) {
+  return pad(true, val, num, str);
+}
+
+export function padRight(val, num, str) {
+  return pad(false, val, num, str);
+}