@sc-voice/tools 3.12.0 → 3.14.0

package/package.json

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

package/src/defines.mjs

@@ -1,6 +1,8 @@
 export const DBG = {
   ALIGN_ALL: 0,
   ALIGN_LINE: 0,
+  I6L_CONTAINS: 0,
+  I6L_OVERLAPS: 0,
   ML_DOC_VECTORS: 0, // 'mn8:3.4',
   MN8_MOHAN: 0,
   DEEPL_ADAPTER: 0,

package/src/math/interval.mjs

@@ -1,20 +1,29 @@
 import { Unicode } from '../text/unicode.mjs';
 const { INFINITY } = Unicode;
+import { ColorConsole } from '../text/color-console.mjs';
+const { cc } = ColorConsole;
+import { DBG } from '../defines.mjs';
 
 const MINUS_INFINITY = `-${INFINITY}`;
 const PLUS_INFINITY = `+${INFINITY}`;
 
 export class Interval {
-  constructor(a, b) {
+  constructor(a, b, opts = {}) {
     const msg = 'i6l.ctor';
     let hi = null;
     let lo = null;
     const dbg = 0;
+    let { leftOpen = false, rightOpen = false } = opts;
+    if (a === INFINITY || a == null) {
+      leftOpen = true;
+    }
+    if (b === INFINITY || b == null) {
+      rightOpen = true;
+    }
 
     let an = typeof a === 'number' && !Number.isNaN(a);
     let bn = typeof b === 'number' && !Number.isNaN(b);
 
-    let isClosed = true;
     if (an && bn) {
       if (b < a) {
         throw new Error(`${msg} invalid interval ${b}<${a}?`);
@@ -22,25 +31,18 @@ export class Interval {
       dbg && console.log(msg, 'an bn');
       lo = a;
       hi = b;
-      isClosed = true;
     } else if (an) {
       dbg && console.log(msg, 'an');
       lo = a;
       hi = INFINITY;
-      isClosed = false;
     } else if (bn) {
       dbg && console.log(msg, 'bn');
       lo = INFINITY;
       hi = b;
-      isClosed = false;
     } else {
       dbg && console.log(msg, '!an !bn');
-      isClosed = false;
     }
 
-    Object.defineProperty(this, 'isClosed', {
-      value: isClosed,
-    });
     Object.defineProperty(this, 'lo', {
       enumerable: true,
       value: lo,
@@ -49,12 +51,28 @@ export class Interval {
       enumerable: true,
       value: hi,
     });
+    Object.defineProperty(this, 'leftOpen', {
+      enumerable: true,
+      value: leftOpen,
+    });
+    Object.defineProperty(this, 'rightOpen', {
+      enumerable: true,
+      value: rightOpen,
+    });
   }
 
   static get INFINITY() {
     return INFINITY;
   }
 
+  get isOpen() {
+    return this.leftOpen || this.rightOpen || this.isEmpty;
+  }
+
+  get isClosed() {
+    return (!this.leftOpen && !this.rightOpen) || this.isEmpty;
+  }
+
   get isEmpty() {
     if (this.lo === null && this.hi === null) {
       return true;
@@ -73,17 +91,30 @@ export class Interval {
     return this.hi === INFINITY ? PLUS_INFINITY : this.hi;
   }
 
+  get degenerate() {
+    return this.hi === this.lo;
+  }
+
   contains(num) {
+    const msg = 'i6l.contains';
+    const dbg = DBG.I6L_CONTAINS;
     if (typeof num !== 'number' || Number.isNaN(num)) {
+      dbg && cc.fyi1(msg+0.1, false);
       return false;
     }
-    let { lo, hi } = this;
+    let { lo, hi, leftOpen, rightOpen } = this;
     if (lo === INFINITY) {
       throw new Error(`${msg}TBD`);
     }
     if (hi === INFINITY) {
       throw new Error(`${msg}TBD`);
     }
+    if (lo === num && leftOpen) {
+      return false;
+    }
+    if (hi === num && rightOpen) {
+      return false;
+    }
     if (lo < num && num < hi) {
       return true;
     }
@@ -116,14 +147,29 @@ export class Interval {
 
   overlaps(iv2) {
     const msg = 'i6l.overlaps';
-    let { lo:lo1, hi:hi1 } = this;
-    let { lo:lo2, hi:hi2 } = iv2;
+    const dbg = DBG.I6L_OVERLAPS;
+    let { lo: lo1, hi: hi1, leftOpen:lOpen1, rightOpen: rOpen1 } = this;
+    let { lo: lo2, hi: hi2, leftOpen:lOpen2, rightOpen: rOpen2 } = iv2;
 
     //console.log(msg, {lo1, lo2, hi1, hi2});
-    return (
-      (lo2 <= lo1 && lo1 <= hi2) ||
-      (lo2 <= hi1 && hi1 <= hi2) ||
-      (lo1 <= lo2 && lo2 <= hi1)
-    );
+    if (!lOpen1 && iv2.contains(lo1)) {
+      dbg && cc.fyi1(msg+1, 'lo1');
+      return true;
+    }
+    if (!rOpen1 && iv2.contains(hi1)) {
+      dbg && cc.fyi1(msg+2, 'hi1');
+      return true;
+    }
+    if (!lOpen2 && this.contains(lo2)) {
+      dbg && cc.fyi1(msg+3, 'lo2');
+      return true;
+    }
+    if (!rOpen2 && this.contains(hi2)) {
+      dbg && cc.fyi1(msg+4, 'hi2');
+      return true;
+    }
+
+    dbg && cc.fyi1(msg+0.1, false);
+    return false;
   }
 }

package/src/text/color-console.mjs

@@ -20,6 +20,8 @@ const {
   NO_COLOR,
 } = Unicode.LINUX_COLOR;
 
+let CC;
+
 export class ColorConsole {
   constructor(opts = {}) {
     let {
@@ -35,7 +37,6 @@ export class ColorConsole {
       colorTag4 = BRIGHT_MAGENTA,
       precision = 3,
       write = (...args) => console.log.call(null, ...args),
-
     } = opts;
 
     Object.assign(this, {
@@ -51,38 +52,48 @@ export class ColorConsole {
       colorTag4,
       precision,
       write,
-
     });
   }
 
+  static get cc() {
+    CC = CC || new ColorConsole();
+    return CC;
+  }
+
   color(color, ...things) {
     let { precision } = this;
     let label = '';
-    return things.reduce((a,thing) => {
+    return things.reduce((a, thing) => {
       let newLabel = '';
       switch (typeof thing) {
-        case 'object':
-          // TODO: pretty objects like console
+        case 'object': {
           label && a.push(label);
-          a.push(thing);
+          let s =
+            thing &&
+            thing.constructor !== Object &&
+            typeof thing.toString === 'function'
+              ? color + thing.toString() + NO_COLOR
+              : thing;
+          a.push(s);
           break;
+        }
         case 'string':
           if (thing.endsWith(':')) {
-            newLabel = NO_COLOR+thing;
+            newLabel = NO_COLOR + thing;
           } else {
-            a.push(label+color+thing+NO_COLOR);
+            a.push(label + color + thing + NO_COLOR);
           }
           break;
         case 'number': {
           let v = thing.toFixed(precision);
           if (thing === Number(v)) {
-            v = v.replace(/\.?0+$/, '')
+            v = v.replace(/\.?0+$/, '');
           }
-          a.push(label+GREEN+v+NO_COLOR);
+          a.push(label + GREEN + v + NO_COLOR);
           break;
         }
         default:
-          a.push(label+color+JSON.stringify(thing)+NO_COLOR);
+          a.push(label + color + JSON.stringify(thing) + NO_COLOR);
           break;
       }
       label = newLabel;

package/src/text/unicode.mjs

@@ -352,7 +352,7 @@ export class Unicode {
   get ELLIPSIS() {
     return Unicode.ELLIPSIS;
   }
-  get IMPLIES(){
+  get IMPLIES() {
     return Unicode.IMPLIES;
   }
   get ELEMENT_OF() {