topazcube 0.0.3 → 0.1.1

package/src/terminal.js

@@ -0,0 +1,144 @@
+/*
+┌─────────┬─────────┬──────┬───────────┬─────────────┬──────────────────┐
+│ Color   │ Example │ Text │ Background│ Bright Text │ Bright Background│
+├─────────┼─────────┼──────┼───────────┼─────────────┼──────────────────┤
+│ Black   │ Black   │ 30   │ 40        │ 90          │ 100              │
+│ Red     │ Red     │ 31   │ 41        │ 91          │ 101              │
+│ Green   │ Green   │ 32   │ 42        │ 92          │ 102              │
+│ Yellow  │ Yellow  │ 33   │ 43        │ 93          │ 103              │
+│ Blue    │ Blue    │ 34   │ 44        │ 94          │ 104              │
+│ Magenta │ Magenta │ 35   │ 45        │ 95          │ 105              │
+│ Cyan    │ Cyan    │ 36   │ 46        │ 96          │ 106              │
+│ White   │ White   │ 37   │ 47        │ 97          │ 107              │
+│ Default │         │ 39   │ 49        │ 99          │ 109              │
+└─────────┴─────────┴──────┴───────────┴─────────────┴──────────────────┘
+
+┌───────────┬─────┬─────┐
+│ Effect    │ On  │ Off │
+├───────────┼─────┼─────┤
+│ Bold      │ 1   │ 21  │
+│ Dim       │ 2   │ 22  │
+│ Underline │ 4   │ 24  │
+│ Blink     │ 5   │ 25  │
+│ Reverse   │ 7   │ 27  │
+│ Hide      │ 8   │ 28  │
+└───────────┴─────┴─────┘
+*/
+
+// Terminal control code constants
+export const T_RESET = 0;
+export const T_BOLD = 1;
+export const T_DIM = 2;
+export const T_UNDERLINE = 4;
+export const T_BLINK = 5;
+export const T_REVERSE = 7;
+export const T_HIDE = 8;
+export const T_BOLD_OFF = 21;
+export const T_DIM_OFF = 22;
+export const T_UNDERLINE_OFF = 24;
+export const T_BLINK_OFF = 25;
+export const T_REVERSE_OFF = 27;
+export const T_HIDE_OFF = 28;
+
+export const T_FG_BLACK = 30;
+export const T_FG_RED = 31;
+export const T_FG_GREEN = 32;
+export const T_FG_YELLOW = 33;
+export const T_FG_BLUE = 34;
+export const T_FG_MAGENTA = 35;
+export const T_FG_CYAN = 36;
+export const T_FG_WHITE = 37;
+export const T_FG_DEFAULT = 39;
+
+export const T_BG_BLACK = 40;
+export const T_BG_RED = 41;
+export const T_BG_GREEN = 42;
+export const T_BG_YELLOW = 43;
+export const T_BG_BLUE = 44;
+export const T_BG_MAGENTA = 45;
+export const T_BG_CYAN = 46;
+export const T_BG_WHITE = 47;
+export const T_BG_DEFAULT = 49;
+
+export const T_FG_BRIGHT_BLACK = 90;
+export const T_FG_BRIGHT_RED = 91;
+export const T_FG_BRIGHT_GREEN = 92;
+export const T_FG_BRIGHT_YELLOW = 93;
+export const T_FG_BRIGHT_BLUE = 94;
+export const T_FG_BRIGHT_MAGENTA = 95;
+export const T_FG_BRIGHT_CYAN = 96;
+export const T_FG_BRIGHT_WHITE = 97;
+export const T_FG_BRIGHT_DEFAULT = 99;
+
+export const T_BG_BRIGHT_BLACK = 100;
+export const T_BG_BRIGHT_RED = 101;
+export const T_BG_BRIGHT_GREEN = 102;
+export const T_BG_BRIGHT_YELLOW = 103;
+export const T_BG_BRIGHT_BLUE = 104;
+export const T_BG_BRIGHT_MAGENTA = 105;
+export const T_BG_BRIGHT_CYAN = 106;
+export const T_BG_BRIGHT_WHITE = 107;
+export const T_BG_BRIGHT_DEFAULT = 109;
+
+
+// Set terminal title
+export function setTitle(title) {
+  process.stdout.write("\x1b]0;" + title + "\x07");
+}
+
+// Set terminal color / effect
+export function setColor(color) {
+  process.stdout.write(`\x1b[${color}m`);
+}
+
+// Reset terminal color
+export function resetColor() {
+  setColor(T_RESET);
+}
+
+// Clear line
+export function clearLine() {
+  process.stdout.write("\x1b[2K");
+}
+
+// Erase to end of line
+export function eraseEOL() {
+  process.stdout.write("\x1b[K");
+}
+
+// Clear screen
+export function clear() {
+  process.stdout.write("\x1b[2J");
+}
+
+// Set cursor position
+export function cursorPosition(line, column) {
+  process.stdout.write(`\x1b[${line};${column}H`);
+}
+// Move cursor up
+export function cursorUp(lines = 1) {
+  process.stdout.write(`\x1b[${lines}A`);
+}
+// Move cursor down
+export function cursorDown(lines = 1) {
+  process.stdout.write(`\x1b[${lines}B`);
+}
+
+// Move cursor forward
+export function cursorForward(columns = 1) {
+  process.stdout.write(`\x1b[${columns}C`);
+}
+// Move cursor backward
+export function cursorBackward(columns = 1) {
+  process.stdout.write(`\x1b[${columns}D`);
+}
+
+// Save cursor position
+export function saveCursor() {
+  process.stdout.write("\x1b[s");
+}
+
+// Restore cursor position
+export function restoreCursor() {
+  process.stdout.write("\x1b[u");
+}

package/src/utils.ts

@@ -0,0 +1,402 @@
+import { Packr } from 'msgpackr';
+import { FLOAT32_OPTIONS } from 'msgpackr';
+const { ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } = FLOAT32_OPTIONS;
+
+let packr = new Packr({
+  useFloat32: ALWAYS
+});
+
+export function encode(obj) {
+  return packr.pack(obj)
+}
+
+export function decode(data) {
+  return packr.unpack(data)
+}
+
+export function reactive(name, object, callback, path = '', excludedProperties = false) {
+  if (object === null || typeof object !== 'object') {
+    //console.log('--- Type not object', typeof object)
+    return object
+  }
+
+  function isReactive(p) {
+    let r = true
+    if (p.startsWith('_')) {
+      r = false
+    }
+    if (excludedProperties) {
+      if (excludedProperties[p]) {
+        r = false
+      }
+    }
+    if (path == '/entities') {
+      r = false
+    }
+    return r
+  }
+
+  for (const property in object) {
+    if (isReactive(property)) {
+      //console.log(`path '${path}', prop '${property}' is reactive`)
+      object[property] = reactive(
+        name,
+        object[property],
+        callback,
+        path + '/' + property,
+        excludedProperties
+      )
+    } else {
+      //console.log(`--- path '${path}', property '${property}' is NOT reactive`)
+    }
+  }
+  //console.log(`path '${path}' is reactive`)
+  return new Proxy(object, {
+    get(target, property, receiver) { // ...arguments
+      return Reflect.get(target, property, receiver)
+    },
+    set(target, property, value) {
+      let newvalue
+      let pn = path + '/' + String(property)
+      if (isReactive(property)) {
+        newvalue = reactive(name, value, callback, pn, excludedProperties)
+        callback(name, 'replace', target, pn, newvalue)
+      } else {
+        newvalue = value
+      }
+      return Reflect.set(target, property, newvalue)
+    },
+    deleteProperty(target, property) {
+      let pn = path + '/' + String(property)
+      delete target[property]
+      if (isReactive(property)) {
+        callback(name, 'delete', target, pn, null)
+      }
+      return true
+    },
+  })
+
+}
+
+export function deepGet(obj, path) {
+  path = path.trimLeft('/')
+  let paths = ('' + path).split('/').filter((p) => p)
+  let len = paths.length
+  for (let i = 0; i < len; i++) {
+    if (obj[paths[i]] == undefined) {
+      return undefined
+    } else {
+      obj = obj[paths[i]]
+    }
+  }
+  return obj
+}
+
+export function deepSet(obj, path, value) {
+  path = path.trimLeft('/')
+  let paths = ('' + path).split('/').filter((p) => p)
+  let len = paths.length
+  let i
+  for (i = 0; i < len - 1; i++) {
+    obj = obj[paths[i]]
+  }
+  obj[paths[i]] = value
+}
+
+// recursive clone oject, without properties that starts with _ (or __)
+
+export function clonewo_(obj, excludeStart = '_') {
+  if (obj === null || typeof obj !== 'object') {
+    return obj
+  }
+
+  function isExcluded(key) {
+    let e = false
+    if (typeof (excludeStart) == 'string' && key.startsWith(excludeStart)) {
+      e = true
+    } else if (typeof(excludeStart) == 'object') {
+      if (excludeStart[key] || key.startsWith('_')) {
+        e = true
+      }
+    }
+    return e
+  }
+
+  if (obj instanceof Map) {
+    const mapClone = new Map()
+    for (let [key, value] of obj) {
+      mapClone.set(clonewo_(key, excludeStart), clonewo_(value, excludeStart))
+    }
+    return mapClone
+  }
+
+  let clone
+  if (Array.isArray(obj)) {
+    clone = []
+    for (let i = 0; i < obj.length; i++) {
+      clone[i] = clonewo_(obj[i], excludeStart)
+    }
+  } else {
+    clone = {}
+    for (let key in obj) {
+      if (obj.hasOwnProperty(key) && !isExcluded(key)) {
+        if (typeof obj[key] === 'object') {
+          clone[key] = clonewo_(obj[key], excludeStart)
+        } else {
+          clone[key] = obj[key]
+        }
+      }
+    }
+  }
+
+  return clone
+}
+
+export function limitPrecision(obj) {
+  if (Array.isArray(obj)) {
+    return obj.map(limitPrecision)
+  } else if (obj !== null && typeof obj === 'object') {
+    const result = {}
+    for (const key in obj) {
+      result[key] = limitPrecision(obj[key])
+    }
+    return result
+  } else if (typeof obj === 'number') {
+    if (Number.isInteger(obj)) {
+      return obj
+    } else {
+      // Limit to max 3 decimal digits, not fixed
+      return parseFloat(obj.toFixed(3))
+    }
+  } else {
+    return obj
+  }
+}
+
+export function msgop(op:any) {
+  let nop:any = {}
+  if (!op.o) {
+    nop.op = 'replace'
+  } else {
+    nop.op = {
+      a: 'add',
+      r: 'remove',
+      d: 'delete',
+      t: 'test',
+    }[op.o]
+  }
+  nop.path = op.p
+  nop.value = op.v
+  return nop
+}
+
+export function opmsg(op, target, path, value) {
+  let c:any = { p: path, v: value }
+  if (op != 'replace') {
+    c.o = {
+      add: 'a',
+      remove: 'r',
+      delete: 'd',
+      test: 't',
+    }[op]
+  }
+  return c
+}
+
+// a function that converts an int to a hexa string
+// (8 characters long)
+export function int2hex(int) {
+  return int.toString(16)
+}
+
+// a function that converts a hexa string to an int
+export function hex2int(str) {
+  if (str.length % 2) {
+    str = '0' + str
+  }
+  return BigInt('0x' + str)
+}
+
+// - Fixed point encoding/decoding functions
+
+// 32-bit unsigned integer encoding
+export function encode_uint32(uint, byteArray, offset = 0) {
+  if (!byteArray) {
+    byteArray = new Uint8Array(4)
+  }
+  let p = offset + 3
+  byteArray[p--] = uint & 0xff
+  uint >>= 8
+  byteArray[p--] = uint & 0xff
+  uint >>= 8
+  byteArray[p--] = uint & 0xff
+  uint >>= 8
+  byteArray[p] = uint
+  return byteArray
+}
+
+// 32-bit unsigned integer decoding
+export function decode_uint32(byteArray, offset = 0) {
+  let p = offset
+  return (
+    ((byteArray[p++] & 0x7f) << 24) |
+    (byteArray[p++] << 16) |
+    (byteArray[p++] << 8) |
+    byteArray[p]
+  )
+}
+
+// 24-bit unsigned integer encoding
+export function encode_uint24(uint, byteArray, offset = 0) {
+  if (!byteArray) {
+    byteArray = new Uint8Array(3)
+  }
+  let p = offset + 2
+  byteArray[p--] = uint & 0xff
+  uint >>= 8
+  byteArray[p--] = uint & 0xff
+  uint >>= 8
+  byteArray[p] = uint
+  return byteArray
+}
+
+// 24-bit unsigned integer decoding
+export function decode_uint24(byteArray, offset = 0) {
+  let p = offset
+  return (
+    (byteArray[p++] << 16) |
+    (byteArray[p++] << 8) |
+    byteArray[p]
+  )
+}
+
+// 16-bit unsigned integer encoding
+export function encode_uint16(uint, byteArray, offset = 0) {
+  if (!byteArray) {
+    byteArray = new Uint8Array(2)
+  }
+  let p = offset + 1
+  byteArray[p--] = uint & 0xff
+  uint >>= 8
+  byteArray[p] = uint
+  return byteArray
+}
+
+// 16-bit unsigned integer decoding
+export function decode_uint16(byteArray, offset = 0) {
+  let p = offset
+  return (byteArray[p++] << 8) | byteArray[p]
+}
+
+// 24.8 bit ====================================================================
+
+// 24.8-bit fixed point encoding
+export function encode_fp248(float, byteArray, offset = 0) {
+  const fp = Math.round(Math.abs(float) * 256)
+  encode_uint32(fp, byteArray, offset)
+  if (float < 0) {
+    byteArray[offset] |= 0x80
+  }
+}
+
+// 24.8-bit fixed point decoding
+export function decode_fp248(byteArray, offset = 0) {
+  const divider = (byteArray[offset] & 0x80) === 0x80 ? -256 : 256
+  byteArray[offset] &= 0x7f
+  const fp = decode_uint32(byteArray, offset)
+  return fp / divider
+}
+
+// 16.8 bit ====================================================================
+
+// 16.8-bit fixed point encoding (3 bytes)
+export function encode_fp168(float, byteArray, offset = 0) {
+  const fp = Math.round(Math.abs(float) * 256)
+  encode_uint24(fp, byteArray, offset)
+  if (float < 0) {
+    byteArray[offset] |= 0x80
+  }
+}
+
+// 16.8-bit fixed point decoding (3 bytes)
+export function decode_fp168(byteArray, offset = 0) {
+  const divider = (byteArray[offset] & 0x80) === 0x80 ? -256 : 256
+  byteArray[offset] &= 0x7f
+  const fp = decode_uint24(byteArray, offset)
+  return fp / divider
+}
+
+// 16.16 bit ===================================================================
+
+// 16.16-bit fixed point encoding
+export function encode_fp1616(float, byteArray, offset = 0) {
+  const fp = Math.round(Math.abs(float) * 65536)
+  encode_uint32(fp, byteArray, offset)
+  if (float < 0) {
+    byteArray[offset] |= 0x80
+  }
+}
+
+// 16.16-bit fixed point decoding
+export function decode_fp1616(byteArray, offset = 0) {
+  const divider = (byteArray[offset] & 0x80) === 0x80 ? -65536 : 65536
+  byteArray[offset] &= 0x7f
+  const fp = decode_uint32(byteArray, offset)
+  return fp / divider
+}
+
+// 8.8 bit =====================================================================
+
+// 8.8-bit fixed point encoding
+export function encode_fp88(float, byteArray, offset = 0) {
+  const fp = Math.round(Math.abs(float) * 256)
+  encode_uint16(fp, byteArray, offset)
+  if (float < 0) {
+    byteArray[offset] |= 0x80
+  }
+}
+
+// 8.8-bit fixed point decoding
+export function decode_fp88(byteArray, offset = 0) {
+  const divider = (byteArray[offset] & 0x80) === 0x80 ? -256 : 256
+  byteArray[offset] &= 0x7f
+  const fp = decode_uint16(byteArray, offset)
+  return fp / divider
+}
+
+// 4.12 bit ====================================================================
+
+// 4.12-bit fixed point encoding
+export function encode_fp412(float, byteArray, offset = 0) {
+  const fp = Math.round(Math.abs(float) * 4096)
+  encode_uint16(fp, byteArray, offset)
+  if (float < 0) {
+    byteArray[offset] |= 0x80
+  }
+}
+
+// 4.12-bit fixed point decoding
+export function decode_fp412(byteArray, offset = 0) {
+  const divider = (byteArray[offset] & 0x80) === 0x80 ? -4096 : 4096
+  byteArray[offset] &= 0x7f
+  const fp = decode_uint16(byteArray, offset)
+  return fp / divider
+}
+
+// 1.7 bit =====================================================================
+
+// 1.7-bit fixed point encoding
+export function encode_fp17(float, byteArray, offset = 0) {
+  const fp = Math.round(Math.abs(float) * 128)
+  byteArray[offset] = fp
+  if (float < 0) {
+    byteArray[offset] |= 0x80
+  }
+}
+
+// 1.7-bit fixed point decoding
+export function decode_fp17(byteArray, offset = 0) {
+  const divider = (byteArray[offset] & 0x80) === 0x80 ? -128.0 : 128.0
+  byteArray[offset] &= 0x7f
+  return byteArray[offset] / divider
+}