@sc-voice/tools 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 SuttaCentral Voice
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,70 @@
+# merkle-json
+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}}";
+```
+
+MerkleJson guarantees a unique hash code for any Javascript object.
+In addition, MerkleJson is efficient in that it only recalculates 
+object hashes if the object has no Merkle hash tag. If a Merkle hash
+tag is present, its value is returned as the hash value of that object.
+
+### Serialize JSON object
+Unlike JSON, MerkleJson serializes objects canonically.
+
+```js
+var obj = {
+    d:4,
+    b:2,
+    a:1,
+    c:3,
+};
+console.log(JSON.stringify(obj)); // {"d":4,"b":2,"a":1,"c":3}
+var mj = new MerkleJson();
+console.log(mj.stringify(obj)); // {"a":1,"b":2,"c":3,"d":4}
+```
+
+### Compute hash of JSON object
+```js
+var mj = new MerkleJson();
+var hash = mj.hash({
+    size:{
+        w:100,
+        h:200
+    }
+}); // e77b735125fec27a61c6f54b17fb6221
+
+var hash = mj.hash({
+    size:{ // hash is independent of property order
+        h:200
+        w:100,
+    }
+}); // e77b735125fec27a61c6f54b17fb6221
+```
+### Do not calculate hash if merkleHash is present
+```js
+var mj = new MerkleJson();
+var useMerkleHash = true;
+var hash = mj.hash({
+    any1: thing1, 
+    any2: thing2, 
+    any3: thing3, 
+}, useMerkleHash); // 441e4f8dabdc6cb17dc9500cee73155b
+
+var hash = mj.hash({
+    ... // anything
+    merkleHash: e77b735125fec27a61c6f54b17fb6221, 
+}, useMerkleHash); // e77b735125fec27a61c6f54b17fb6221
+
+var useMerkleHash = false; // force hash calculation
+var hash = mj.hash({
+    any1: thing1, 
+    any2: thing2, 
+    any3: thing3, 
+    merkleHash: e77b735125fec27a61c6f54b17fb6221, // ignored
+}, useMerkleHash); // 441e4f8dabdc6cb17dc9500cee73155b
+```

package/index.mjs

@@ -0,0 +1,31 @@
+
+import { Fraction } from './src/math/fraction.mjs';
+
+export const ScvMath = {
+  Fraction,
+};
+
+import { 
+  Aligner, Alignment, AlignmentStatus 
+} from './src/text/aligner.mjs';
+import { BilaraPath } from './src/text/bilara-path.mjs';
+import { EbtDoc } from './src/text/ebt-doc.mjs';
+import { LegacyDoc } from './src/text/legacy-doc.mjs';
+import { MerkleJson } from './src/text/merkle-json.mjs';
+import { SuttaCentralId } from './src/text/sutta-central-id.mjs';
+import { Unicode } from './src/text/unicode.mjs';
+import { WordSpace } from './src/text/word-space.mjs';
+
+export const Text = {
+  Aligner,
+  Alignment,
+  AlignmentStatus,
+  BilaraPath,
+  EbtDoc,
+  LegacyDoc,
+  MerkleJson,
+  SuttaCentralId,
+  Unicode,
+  WordSpace,
+};
+

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@sc-voice/tools",
+  "version": "1.1.0",
+  "description": "Utilities for SC-Voice",
+  "main": "index.mjs",
+  "files": [
+    "LICENSE",
+    "index.mjs",
+    "package.json",
+    "README.md",
+    "src"
+  ],
+  "scripts": {
+    "test": "mocha --inline-diffs --recursive",
+    "test:test": "mocha --config test/mocha-config.json --recursive"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/sc-voice/tools.git"
+  },
+  "keywords": [
+    "SC-Voice tools",
+    "merkle-json",
+    "Javascript"
+  ],
+  "author": "Karl Lew",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/sc-voice/tools/issues"
+  },
+  "homepage": "https://github.com/sc-voice/tools#readme",
+  "devDependencies": {
+    "@biomejs/biome": "1.9.4",
+    "eslint": "^9.17.0",
+    "mocha": "^11.0.1",
+    "should": "^13.2.3"
+  }
+}

package/src/defines.mjs

@@ -0,0 +1,9 @@
+
+export const DBG = {
+  APPLY_WORD_MAP: 0,
+  ALIGN_ALL: 0,
+  ALIGN_LINE: 0,
+  ML_DOC_VECTORS: 0, // 'mn8:3.4',
+  MN8_MOHAN: 0,
+};
+

package/src/math/fraction.mjs

@@ -0,0 +1,94 @@
+export class Fraction {
+  constructor(...args) {
+    //constructor(numerator, denominator = 1, units = undefined) {
+    const msg = 'Fraction.ctor:';
+    if (args[0] instanceof Fraction) {
+      let { numerator: n, denominator: d, units: u } = args[0];
+      args = [n, d, u];
+    }
+    let [numerator, denominator = 1, units = undefined] = args;
+
+    Object.assign(this, {
+      numerator,
+      denominator,
+      units,
+    });
+  }
+
+  static gcd(a, b) {
+    if (b === 0) {
+      return a;
+    }
+    return Fraction.gcd(b, a % b);
+  }
+
+  get remainder() {
+    let { n, d } = this;
+
+    return n % d;
+  }
+
+  get difference() {
+    let { n, d } = this;
+    return n - d;
+  }
+
+  get percent() {
+    return (this.value * 100).toFixed(0) + '%';
+  }
+
+  get n() {
+    return this.numerator;
+  }
+
+  get d() {
+    return this.denominator;
+  }
+
+  get value() {
+    let { numerator, denominator } = this;
+    return numerator / denominator;
+  }
+
+  increment(delta = 1) {
+    this.numerator += Math.round(delta);
+    return this;
+  }
+
+  reduce() {
+    let { numerator: n, denominator: d, units } = this;
+    if (Number.isInteger(n) && Number.isInteger(d)) {
+      let g = Fraction.gcd(n, d);
+      if (g) {
+        this.numerator /= g;
+        this.denominator /= g;
+      }
+    }
+    return this;
+  }
+
+  toString() {
+    let { units, numerator: n, denominator: d, value } = this;
+    if (n == null || d == null) {
+      return `${n}/${d}`;
+    }
+    if (d < 0) {
+      d = -d;
+      n = -n;
+    }
+    let s = d === 1 ? `${n}` : `${n}/${d}`;
+
+    return units ? `${s} ${units}` : s;
+  }
+
+  add(f) {
+    const msg = 'Fraction.add:';
+    let { numerator: n1, denominator: d1, units: u1 } = this;
+    let { numerator: n2, denominator: d2, units: u2 } = f;
+    if (this.units !== f.units) {
+      throw new Error(`${msg} units? ${u1}? ${u2}?`);
+    }
+
+    return new Fraction(n1 * d2 + n2 * d1, d1 * d2).reduce();
+  }
+}