rita 3.0.8 → 3.0.10

package/README.md

@@ -10,7 +10,7 @@ RiTa is implemented in JavaScript and Java, with a common [API](https://github.c
 * Smart lexicon search for words matching part-of-speech, syllable, stress and rhyme patterns
 * Fast, heuristic algorithms for inflection, conjugation, stemming, tokenization, and more
 * Letter-to-sound engine for feature analysis of arbitrary words (with/without lexicon)
-* Integration of the [RiScript](https://observablehq.com/@dhowe/riscript) scripting language, designed for writers
+* Integration of the [RiScript](https://observablehq.com/@dhowe/riscript) scripting language, designed for writers, now built with the blazing fast [Chevrotain](https://chevrotain.io/) parser
 * New options for generation via grammars and Markov chains
 * Published in ESM, CommonJS and as an IIFE
 
@@ -32,7 +32,7 @@ let data = RiTa.analyze("The elephant took a bite!");
 console.log(data);
 
 // to load a grammar
-let grammar = RiTa.grammar(jsonRules);
+let grammar = RiTa.grammar(rulesObjectOrJSON);
 console.log(grammar.expand());
 ```
 
@@ -158,7 +158,7 @@ Some of the following extensions may also be useful:
 
 Here you can see the tests in the VSCode _Testing_ view
 
-<img width="800" alt="vscode-tests" src="https://user-images.githubusercontent.com/737638/166626482-bd28d9fa-b300-4b26-b2d7-7ecb6cf31866.png">
+<img width="800" alt="vscode-tests" src="https://github.com/dhowe/ritajs/assets/737638/103665fb-3dc8-448b-9ed3-d706be6797fc">
 
 &nbsp;
 

package/dist/rita.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }var __defProp = Object.defineProperty;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => {
   __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -4789,6 +4789,9 @@ var Util = class _Util {
   static isNum(n) {
     return !isNaN(parseFloat(n)) && isFinite(n);
   }
+  static numOpt(opts, name, def = 0) {
+    return _Util.isNum(_optionalChain([opts, 'optionalAccess', _ => _[name]])) ? opts[name] : def;
+  }
 };
 var RE2 = class {
   constructor(regex2, offset, suffix) {
@@ -26971,41 +26974,8 @@ var Lexicon = class {
     }
     return false;
   }
-  /*findStem(word) { // JC: what is this function doing?
-  
-      let part = word;
-      let dict = this.data;
-      let words = Object.keys(dict);
-  
-      while (part.length > 1) {
-  
-        let pattern = new RegExp('^' + part);
-        let guess = words.filter(w => pattern.test(w));
-        if (guess && guess.length) {
-  
-          // always look for shorter words first
-          guess.sort((a, b) => a.length - b.length);
-  
-          // look for words stem(b)===a
-          for (let i = 0; i < guess.length; i++) {
-            if (this.RiTa.stem(guess[i]) === word) {
-              return guess[i];
-            }
-          }
-        }
-        part = part.slice(0, -1);
-      }
-  
-      return undefined;
-    }*/
-  async alliterations(theWord, opts = {}) {
-    return new Promise((resolve, reject) => {
-      try {
-        resolve(this.alliterationsSync(theWord, opts));
-      } catch (e) {
-        reject(e);
-      }
-    });
+  async alliterations(word, options = {}) {
+    return this._promise(this.alliterationsSync, [word, options]);
   }
   alliterationsSync(theWord, opts = {}) {
     this._parseArgs(opts);
@@ -27052,14 +27022,8 @@ var Lexicon = class {
     }
     return result;
   }
-  async rhymes(theWord, opts = {}) {
-    return new Promise((resolve, reject) => {
-      try {
-        resolve(this.rhymesSync(theWord, opts));
-      } catch (e) {
-        reject(e);
-      }
-    });
+  async rhymes(word, options = {}) {
+    return this._promise(this.rhymesSync, [word, options]);
   }
   rhymesSync(theWord, opts = {}) {
     this._parseArgs(opts);
@@ -27097,13 +27061,7 @@ var Lexicon = class {
     return result;
   }
   async spellsLike(word, options = {}) {
-    return new Promise((resolve, reject) => {
-      try {
-        resolve(this.spellsLikeSync(word, options));
-      } catch (e) {
-        reject(e);
-      }
-    });
+    return this._promise(this.spellsLikeSync, [word, options]);
   }
   spellsLikeSync(word, options = {}) {
     if (!word || !word.length)
@@ -27112,13 +27070,7 @@ var Lexicon = class {
     return this._byTypeSync(word, options);
   }
   async soundsLike(word, options = {}) {
-    return new Promise((resolve, reject) => {
-      try {
-        resolve(this.soundsLikeSync(word, options));
-      } catch (e) {
-        reject(e);
-      }
-    });
+    return this._promise(this.soundsLikeSync, [word, options]);
   }
   soundsLikeSync(word, opts = {}) {
     if (!word || !word.length)
@@ -27137,9 +27089,10 @@ var Lexicon = class {
       }
     }
     opts = opts || {};
-    opts.strictPos = true;
-    opts.shuffle = true;
     opts.limit = 1;
+    opts.shuffle = true;
+    opts.strictPos = true;
+    opts.minLength = util_default.numOpt(opts, "minLength", 4);
     let result = this.searchSync(regex2, opts);
     if (result.length < 1 && opts.hasOwnProperty("pos")) {
       opts.strictPos = false;
@@ -27152,13 +27105,7 @@ var Lexicon = class {
     return result[0];
   }
   async search(pattern, options) {
-    return new Promise((resolve, reject) => {
-      try {
-        resolve(this.searchSync(pattern, options));
-      } catch (e) {
-        reject(e);
-      }
-    });
+    return this._promise(this.searchSync, [pattern, options]);
   }
   searchSync(pattern, options) {
     let words = Object.keys(this.data);
@@ -27209,15 +27156,6 @@ var Lexicon = class {
     return dict ? Object.keys(dict).length : 0;
   }
   //////////////////////////// helpers /////////////////////////////////
-  // async similarByType(pattern, options) {
-  //   return new Promise((resolve, reject) => {
-  //     try {
-  //       resolve(this.similarByTypeSync(pattern, options));
-  //     } catch (e) {
-  //       reject(e);
-  //     }
-  //   });
-  // }
   _byTypeSync(theWord, opts) {
     this._parseArgs(opts);
     const dict = this.data;
@@ -27302,14 +27240,13 @@ var Lexicon = class {
   // Handles: pos, limit, numSyllables, minLength, maxLength
   // potentially appends pluralize, conjugate, targetPos
   _parseArgs(opts) {
-    opts.limit = opts.limit || 10;
-    opts.minDistance = opts.minDistance || 1;
-    opts.numSyllables = opts.numSyllables || 0;
-    opts.maxLength = opts.maxLength || Number.MAX_SAFE_INTEGER;
-    opts.minLength = opts.minLength || 3;
-    if (typeof opts.limit !== "number" || opts.limit < 1) {
+    opts.limit = util_default.numOpt(opts, "limit", 10);
+    opts.minDistance = util_default.numOpt(opts, "minDistance", 1);
+    opts.numSyllables = util_default.numOpt(opts, "numSyllables", 0);
+    opts.maxLength = util_default.numOpt(opts, "maxLength", Number.MAX_SAFE_INTEGER);
+    opts.minLength = util_default.numOpt(opts, "minLength", 3);
+    if (opts.limit < 1)
       opts.limit = Number.MAX_SAFE_INTEGER;
-    }
     let tpos = opts.pos || false;
     if (tpos && tpos.length) {
       opts.pluralize = tpos === "nns";
@@ -27352,13 +27289,7 @@ var Lexicon = class {
   }
   async _bySoundAndLetter(word, opts) {
     let types = ["sound", "letter"];
-    let promises = types.map((type) => new Promise((resolve, reject) => {
-      try {
-        resolve(this._byTypeSync(word, { ...opts, type }));
-      } catch (e) {
-        reject(e);
-      }
-    }));
+    let promises = types.map((type) => this._promise(this._byTypeSync, [word, { ...opts, type }]));
     let results = await Promise.allSettled(promises);
     let [bySound, byLetter] = results.map((r) => r.value);
     if (bySound.length < 1 || byLetter.length < 1)
@@ -27407,6 +27338,15 @@ var Lexicon = class {
     return w.endsWith("ness") || w.endsWith("ism") || pos.indexOf("vbg") > 0 || util_default.MASS_NOUNS.includes(w);
   }
   // helpers ---------------------------------------------------------------
+  _promise(fun, args) {
+    return new Promise((resolve, reject) => {
+      try {
+        resolve(fun.apply(this, args));
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
   _parseRegex(regex2, opts) {
     if (typeof regex2 === "string") {
       if (opts && opts.type === "stresses") {
@@ -42685,7 +42625,7 @@ RiTa2.SILENT = false;
 RiTa2.SILENCE_LTS = false;
 RiTa2.CDN = "https://www.unpkg.com/rita/";
 RiTa2.PHONES = ["aa", "ae", "ah", "ao", "aw", "ay", "b", "ch", "d", "dh", "eh", "er", "ey", "f", "g", "hh", "ih", "iy", "jh", "k", "l", "m", "n", "ng", "ow", "oy", "p", "r", "s", "sh", "t", "th", "uh", "uw", "v", "w", "y", "z", "zh"];
-RiTa2.VERSION = "3.0.8";
+RiTa2.VERSION = "3.0.10";
 RiTa2.HAS_LEXICON = typeof __NOLEX__ === "undefined";
 RiTa2.FIRST = 1;
 RiTa2.SECOND = 2;