@sc-voice/tools 2.0.0 → 2.1.0

package/README.md

@@ -1,12 +1,37 @@
-# merkle-json
+# @sc-voice/tools
+Javascript libary for SC-Voice applications
+
+* Math 
+* Text
+* Graph
+
+## Math.Fraction
+```
+let f = new Fraction(9, 240, 'segments');
+console.log(f.value); // 0.375
+console.log(f.numerator, f.denominator); // 9 240
+console.log(f.n, f.d); // 9 240
+console.log(f.toString()); // 1/2 segments
+console.log(Fraction.gcd(9, 240)); // 3
+console.log(f.difference); // -150
+console.log(f.remainder); // 9
+console.log(f.percent); // '4%'
+console.log(f.add(new Fraction(1,80)); // new Fraction(4,80)
+```
+
+## Text.WordSpace
+Used for text similarity comparison, WordSpace creates and compares
+Vectors of words weighted by normalized frequency of occurrence.
+Weights and scores are normalized to the interval [0..1].
+
+## Text.MerkleJson
 Computing the hash of JSON objects can be tricky because JSON.stringify()
 does not have a guaranteed string representation of a Javascript object.
 Specifically, the following are equivalent and valid outputs of JSON.stringify():
 
 ```js
 var json = "{size:{w:100,h:200}}";
-var json = "{size:{h:100,w:200}}";
-```
+var json = "{size:{h:100,w:200}}"; ```
 
 MerkleJson guarantees a unique hash code for any Javascript object.
 In addition, MerkleJson is efficient in that it only recalculates 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sc-voice/tools",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Utilities for SC-Voice",
   "main": "index.mjs",
   "files": [

package/src/text/logger.mjs

@@ -41,24 +41,51 @@ export class LogEntry {
   }
 }
 
+const LEVEL_DEBUG = { id: 'D', priority: -1 };
+const LEVEL_INFO = { id: 'I', priority: 0 };
+const LEVEL_WARN = { id: 'W', priority: 1 };
+const LEVEL_ERROR = { id: 'E', priority: 2 };
+const LEVEL_LOG = { id: 'L', priority: 3 };
+
 export class Logger {
   constructor(opts = {}) {
-    let { sink = console, msBase = Date.now() } = opts;
+    let {
+      sink = console,
+      msBase = Date.now(),
+      logLevel = Logger.LEVEL_WARN,
+    } = opts;
     Object.assign(this, {
       history: [],
       sink,
       msBase,
+      logLevel,
     });
   }
 
+  static get LEVEL_DEBUG() {
+    return LEVEL_DEBUG;
+  }
+  static get LEVEL_INFO() {
+    return LEVEL_INFO;
+  }
+  static get LEVEL_WARN() {
+    return LEVEL_WARN;
+  }
+  static get LEVEL_ERROR() {
+    return LEVEL_ERROR;
+  }
+  static get LEVEL_LOG() {
+    return LEVEL_LOG;
+  }
+
   addEntry(level, args, fSink) {
     const msg = 'l4r.addEntry;';
     const dbg = DBG.L4R_ADD_ENTRY;
-    let { history, sink, msBase } = this;
+    let { logLevel, history, sink, msBase } = this;
     let ms = Date.now() - msBase;
     let entry = LogEntry.fromArgs(level, args, ms);
     history.push(entry);
-    if (sink) {
+    if (sink && level.priority >= logLevel.priority) {
       dbg && console.log(msg, 'sink');
       fSink?.apply(sink, args);
     }
@@ -66,22 +93,23 @@ export class Logger {
   }
 
   debug(...args) {
-    return this.addEntry('D', args, this.sink?.debug);
+    return this.addEntry(LEVEL_DEBUG, args, this.sink?.debug);
   }
 
   info(...args) {
-    return this.addEntry('I', args, this.sink?.info);
-  }
-
-  log(...args) {
-    return this.addEntry('L', args, this.sink?.log);
+    return this.addEntry(LEVEL_INFO, args, this.sink?.info);
   }
 
   warn(...args) {
-    return this.addEntry('W', args, this.sink?.warn);
+    return this.addEntry(LEVEL_WARN, args, this.sink?.warn);
   }
 
   error(...args) {
-    return this.addEntry('E', args, this.sink?.error);
+    return this.addEntry(LEVEL_ERROR, args, this.sink?.error);
   }
+
+  log(...args) {
+    return this.addEntry(LEVEL_INFO, args, this.sink?.log);
+  }
+
 }