word-games-theme 1.7.1 → 1.7.3

data/assets/js/multiple-word-anagram-solver.js

@@ -2,104 +2,345 @@ const form = document.getElementById("form");
 const input = document.getElementById("phrase");
 const selectedDictionary = document.getElementById("dict");
 const main = document.querySelector("#results");
-const contains = document.querySelector("#contains")
-const sort_dir = document.querySelector("#sort_dir")
-const errorMessage = document.querySelector(".error-message")
+const subResult = document.querySelector("#main-results");
+const contains = document.querySelector("#contains");
+const sort_dir = document.querySelector("#sort_dir");
+const errorMessage = document.querySelector(".error-message");
 const getScript = document.currentScript;
 let script = document.currentScript;
 const siteUrl = getScript.dataset.url;
 const min_letters = document.querySelector("#min_letters");
+const max_words = document.querySelector("#max_words");
+const limit = document.querySelector("#max_results");
+let loadMore = document.querySelector("#loadMore");
+let lazyLoader = document.getElementById("lazy-loader");
+var resultArr = [];
+var found = new Set();
+var scrabbleWordArr = [];
 input.focus();
+var wcount = 0;
+var m_words = 0;
 function getCombinations(arr, n) {
-    var i,
-        j,
-        k,
-        elem,
-        l = arr.length,
-        childperm,
-        ret = [];
-    if (n == 1) {
-        for (i = 0; i < arr.length; i++) {
-            for (j = 0; j < arr[i].length; j++) {
-                ret.push([arr[i][j]]);
-            }
-        }
-        return ret;
-    } else {
-        for (i = 0; i < l; i++) {
-            elem = arr.shift();
-            for (j = 0; j < elem.length; j++) {
-                childperm = getCombinations(arr.slice(), n - 1);
-                for (k = 0; k < childperm.length; k++) {
-                    ret.push([elem[j]].concat(childperm[k]));
-                }
-            }
+  var i,
+    j,
+    k,
+    elem,
+    l = arr.length,
+    childperm,
+    ret = [];
+  if (n == 1) {
+    for (i = 0; i < arr.length; i++) {
+      for (j = 0; j < arr[i].length; j++) {
+        ret.push([arr[i][j]]);
+      }
+    }
+    return ret;
+  } else {
+    for (i = 0; i < l; i++) {
+      elem = arr.shift();
+      for (j = 0; j < elem.length; j++) {
+        childperm = getCombinations(arr.slice(), n - 1);
+        for (k = 0; k < childperm.length; k++) {
+          ret.push([elem[j]].concat(childperm[k]));
         }
-        return ret;
+      }
     }
+    return ret;
+  }
 }
 let numberOfWords = 3;
 const getData = async (e) => {
-    e.preventDefault();
-    main.innerHTML = `<div class="loader">
+  main.innerHTML = "";
+  e.preventDefault();
+  subResult.innerHTML = `<div class="loader">
     <img src='/assets/images/loading.gif'>
     <div style="font-weight:900;font-size:14px" >Finding words - Powered by anagramsolvers.org</div>
     </div>`;
-    const response = await fetch(
-        `/.netlify/functions/getMultipleWords?name=${input.value.toLowerCase()}&selecteddictionary=${selectedDictionary.value
-        }`
-    );
-    const data = await response.json();
-    main.innerHTML = "";
-
-    let newdata = data
-    if (newdata.length == []) {
-        errorMessage.style.display = "block"
-        document.querySelector(".heading-result").style.display = "none"
-    } else {
-        errorMessage.style.display = "none"
-        document.querySelector(".heading-result").style.display = "block"
-        if (sort_dir.value === "desc") {
-            newdata = data.reverse()
-        }
-        if (contains.value) {
-            newdata = newdata.filter((item) =>
-                item.words.includes(contains.value.toLowerCase())
-            );
+  const response = await fetch(
+    `/.netlify/functions/getWords?name=${input.value.toLowerCase()}&selecteddictionary=${
+      selectedDictionary.value
+    }`
+  );
+  var data = await response.json();
+
+  console.time("time taken");
+  data = getCombo(data, max_words.value);
+  console.timeEnd("time taken");
+
+  // main.innerHTML = "";
+
+  // let newdata = data;
+
+  // if (newdata.length == []) {
+  //   errorMessage.style.display = "block";
+  //   document.querySelector(".heading-result").style.display = "none";
+  // } else {
+  //   errorMessage.style.display = "none";
+  //   document.querySelector(".heading-result").style.display = "block";
+  //   if (sort_dir.value === "desc") {
+  //     newdata = data.reverse();
+  //   }
+  //   if (contains.value) {
+  //     newdata = newdata.filter((item) =>
+  //       item.includes(contains.value.toLowerCase())
+  //     );
+  //   }
+
+  //   newdata.map((item) => {
+  //     let nWords = item.split(" ");
+  //     var wordHtml = "";
+
+  //     nWords.map((word) => {
+  //       wordHtml += `<a style="margin:0 5px 0 0; font-size:14px; color:#007bff" title="Lookup ${word} in Dictionary" target="_blank" href="/word-meaning?search=${word}">${word}</a>`;
+  //     });
+  //     let html = `<div class="col-lg-3 col-md-4 col-sm-6 col-xs-6">
+  //     ${wordHtml}
+  //       </div>`;
+  //     // main.innerHTML += `${html}`;
+  //     main.insertAdjacentHTML("beforeend", html);
+  //   });
+  // }
+  // resultArr = [];
+  // found.clear();
+  // scrabbleWordArr = [];
+  // console.timeEnd("Process time");
+};
+
+form.addEventListener("submit", getData);
+
+function arraysEqual(a1, a2) {
+  return JSON.stringify(a1.sort()) == JSON.stringify(a2.sort());
+}
+
+async function getCombo(arr, m_words) {
+  var userValue = input.value.trim().toLowerCase().split("");
+  var combinations = [];
+  scrabbleWordArr = arr;
+  m_words = +max_words.value;
+
+  arr.map((v) => {
+    validWord(v.replace(" ", "").split(""), userValue, v);
+  });
+
+  var combinations = arr.flatMap((v, i) => {
+    return arr.slice(i + 1).map((w) => {
+      var newWord = v + " " + w;
+      validWord(newWord.replace(" ", "").split(""), userValue, newWord);
+      return newWord;
+    });
+  });
+  displayUi(resultArr, combinations, userValue, m_words, scrabbleWordArr);
+}
+
+const equalsCheck = (a, b) => {
+  a = a.sort();
+  b = b.sort();
+  return JSON.stringify(a) === JSON.stringify(b);
+};
+
+function getComboWords(arr1, arr2, userValue) {
+  var w_limit = limit.value;
+  var count = 0;
+  var combArr = [];
+
+  console.log("inside combo");
+
+  arr2 = arr2.filter((ele) => {
+    var repeat = getMatchedChars(ele, userValue);
+    if (repeat) {
+      return ele;
+    }
+  });
+
+  arr1 = arr1.filter((ele) => {
+    var repeat = getRepeatedChars(ele, userValue);
+    if (ele.replaceAll(" ", "").length <= userValue.length && repeat) {
+      return ele;
+    }
+  });
+
+  for (let i = 0; i < arr1.length; i++) {
+    var arr_word = arr1[i];
+    if (
+      arr_word != undefined &&
+      arr_word.replaceAll(" ", "").length <
+        input.value.replaceAll(" ", "").length
+    ) {
+      for (let j = 0; j < arr2.length; j++) {
+        var arr2_word = arr2[j];
+        var nWord = arr_word + " " + arr2_word;
+        var nWord_w_space = nWord.replaceAll(" ", "").split("");
+        if (
+          nWord_w_space.length >= userValue.length &&
+          validWord(nWord_w_space, userValue, nWord)
+        ) {
+          count++;
+          // // display([nWord]);
+          // blockForFiveMilliSeconds();
+          printIndex = resultArr.length;
+          // scrabbleWordArr.splice(j, 1);
         }
-        let result = []
-        newdata.map((item) => {
-            result.push(item.words[0] + " " + item.words[1])
-        })
-        result.map((ele, index, self) => {
-            self.filter((f, j) => {
-                if (j != index) {
-                    var word = f.toLowerCase().split(" ").reverse().join(" ");
-                    if (ele.includes(word)) {
-                        delete result[j]
-                    }
-                }
-            })
-        })
-        result.map((item) => {
-            let word = item.split(" ")[0]
-            let word2 = item.split(" ")[1]
-
-            let newWord = ""
-            if (word2 != "undefined") {
-                newWord = word2
-            }
-            let html = `<div class="col-lg-3 col-md-4 col-sm-6 col-xs-6">
-        <a style="margin:0 5px 0 0; font-size:14px; color:#007bff" title="Lookup ${word} in Dictionary" target="_blank" href="/word-meaning?search=${word}">${word}</a>
-        <a style="margin:0 5px 0 0; font-size:14px; color:#007bff" title="Lookup ${word2} in Dictionary" target="_blank" href="/word-meaning?search=${word2}">${newWord}</a>
-        </div>`;
-            main.innerHTML += `${html}`
-
-        })
+        combArr.push(nWord);
+      }
+    }
+    if (count > 0 && count + resultArr.length >= w_limit) {
+      break;
+    }
+  }
+
+  combArr = combArr.filter((e) => e != undefined);
+  return combArr;
+}
+
+function validWord(wordT, userValue, ele) {
+  var sort_ele = ele.split(" ").sort().join(" ");
+  if (arraysEqual(wordT, userValue) && !found.has(sort_ele)) {
+    found.add(sort_ele);
+    resultArr.push(ele);
+    return true;
+  }
+  return false;
+}
+
+const getRepeatedChars = (str, userInput) => {
+  var flag = false;
+  const charsStr = {};
+  const charsUserInput = {};
+
+  for (const char of str.replace(" ", "")) {
+    charsStr[char] = (charsStr[char] || 0) + 1;
+  }
+  for (const char of userInput.join("")) {
+    charsUserInput[char] = (charsUserInput[char] || 0) + 1;
+  }
+  var str_repeat = Object.entries(charsStr)
+    .filter((char) => char[1] > 1)
+    .map((char) => char[0]);
+
+  var input_repeat = Object.entries(charsUserInput)
+    .filter((char) => char[1] > 1)
+    .map((char) => char[0]);
+
+  for (let i = 0; i < str_repeat.length; i++) {
+    let c = str_repeat[i];
+    if (input_repeat.includes(c)) {
+      var i_count = charsUserInput[c];
+      var str_count = charsStr[c];
+      if (str_count <= i_count) {
+        flag = true;
+      }
+    } else {
+      flag = false;
+      break;
+    }
+  }
+  return flag;
+};
+
+const getMatchedChars = (str, userInput) => {
+  var flag = false;
+  const charsStr = {};
+  const charsUserInput = {};
+
+  for (const char of str.replace(" ", "")) {
+    charsStr[char] = (charsStr[char] || 0) + 1;
+  }
+  for (const char of userInput.join("")) {
+    charsUserInput[char] = (charsUserInput[char] || 0) + 1;
+  }
+  var str_repeat = Object.entries(charsStr)
+    .filter((char) => char[1] >= 1)
+    .map((char) => char[0]);
+
+  var input_repeat = Object.entries(charsUserInput)
+    .filter((char) => char[1] > 1)
+    .map((char) => char[0]);
+
+  for (let i = 0; i < str_repeat.length; i++) {
+    let c = str_repeat[i];
+    if (userInput.includes(c)) {
+      var i_count = charsUserInput[c];
+      var str_count = charsStr[c];
+      if (str_count <= i_count) {
+        flag = true;
+      }
+    } else {
+      flag = false;
+      break;
     }
+  }
+  return flag;
 };
+//n is max  word
+async function displayUi(newdata, combinations, userValue, n, wordArr) {
+  // console.log("printed for firsTime");
+  if (newdata.length == []) {
+    if (found.size == 0) {
+      errorMessage.style.display = "block";
+      document.querySelector(".heading-result").style.display = "none";
+    }
+  } else {
+    errorMessage.style.display = "none";
+    document.querySelector(".heading-result").style.display = "block";
+    if (sort_dir.value === "desc") {
+      newdata = data.reverse();
+    }
+    if (contains.value) {
+      newdata = newdata.filter((item) =>
+        item.includes(contains.value.toLowerCase())
+      );
+    }
+
+    requestAnimationFrame(() => {
+      newdata.map((item, index) => {
+        var i = 0;
+        let nWords = item.split(" ");
+        var wordHtml = "";
 
+        nWords.map((word) => {
+          wordHtml += `<a style="margin:0 5px 0 0; font-size:14px; color:#007bff" title="Lookup ${word} in Dictionary" target="_blank" href="/word-meaning?search=${word}">${word}</a>`;
+        });
 
+        var dataDiv = document.createElement("div");
+        dataDiv.className = "col-lg-3 col-md-4 col-sm-6 col-xs-6";
 
+        dataDiv.insertAdjacentHTML("beforeend", wordHtml);
+
+        main.insertAdjacentElement("beforeend", dataDiv);
+        subResult.innerHTML = "";
+        lazyLoader.style.display = "block";
+      });
+      resultArr = [];
+      if (n > 2) {
+        wordArr = wordArr.filter(
+          (w) => w.length < Math.round(userValue.length / 2)
+        );
+        // console.time("combination time");
+        var data = getComboWords(combinations, wordArr, userValue);
+        // console.timeEnd("combination time");
+        n--;
+        console.log("calling display ui from recursion");
+        if (data.length != 0) {
+          displayUi(resultArr, data, userValue, n, wordArr);
+        } else {
+          found.clear();
+          // console.log("refreshing");
+          m_words = +max_words.value;
+          scrabbleWordArr = [];
+          lazyLoader.style.display = "none";
+        }
+      } else {
+        found.clear();
+        // console.log("refreshing");
+        m_words = +max_words.value;
+        scrabbleWordArr = [];
+        lazyLoader.style.display = "none";
+      }
+    });
+  }
+}
 
-form.addEventListener("submit", getData);
+// function showLoader() {
+//   lazyLoader.style.display = "block";
+//   loadMore.style.display = "none";
+// }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: word-games-theme
 version: !ruby/object:Gem::Version
-  version: 1.7.1
+  version: 1.7.3
 platform: ruby
 authors:
 - manpreet-appscms
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-11 00:00:00.000000000 Z
+date: 2023-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -223,7 +223,6 @@ files:
 - assets/images/Arjyahi.webp
 - assets/images/EMDI - Hurts Like This (feat. Veronica Bravo) [NCS Release].mp3
 - assets/images/Nikita.webp
-- assets/images/Resume - Google Docs.pdf
 - assets/images/abp.svg
 - assets/images/adblock.svg
 - assets/images/alka.webp
@@ -255,6 +254,7 @@ files:
 - assets/images/linkedin.svg
 - assets/images/linkedin2.svg
 - assets/images/loading.gif
+- assets/images/manpreet-spinner.gif
 - assets/images/next.webp
 - assets/images/paavan.webp
 - assets/images/pallavi.jpeg
@@ -329,7 +329,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.3.5
 signing_key: 
 specification_version: 4
 summary: Word-Games theme for all word-games-sites