word-games-theme 2.8.0 → 2.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5df4720a7fc2541995554657951e55b1ba0de00e047f07048b89acbe1953a8e4
-  data.tar.gz: a2f908b9a172e07275569bbd709a75e38f9b5f2b28221e167fd6a0027a843be1
+  metadata.gz: 17543ce741f1baf1603be070f547faa129ea0b2703492c0fa418cbea54fbd50a
+  data.tar.gz: d8b0b9bd3b601d0a247d0c12d138bbd42c9897cf4cb40992624c384f8b6b83ba
 SHA512:
-  metadata.gz: d5450914e354f403c90239d934f315b2d1082c41dbda586942af093e233c475315b5564228c4311b58a76b13d8b4f73b82a036d1eb215a34fe14bfde76421683
-  data.tar.gz: cb5a93d653727f0feff0ff0be046b11f9ccef12eadd3d0d2fa2a9f5c345c946db796966343b9b7704cfb1690cfc903be04f05aebbca833d1201f5780a705777d
+  metadata.gz: 405d3f0bccfa8c5ba69aab5c1ef9e1c4208266a1a29f6e4f3425f5ebaa4578087d070c5cc5857fa446eaeb01b3818768003a9cf2f227c0391157ade011a05d5a
+  data.tar.gz: a41b7171d014c4c82036d7935f61c8000d5b3ac06f2b8b37aef9698bad619dc3aa2d502ba07154d599fe28eba85b5b8f39e8482f2bc0439ebea9be880f2326b5

data/assets/js/wordfinder-worker.js

@@ -0,0 +1,262 @@
+self.onmessage = async (event) => {
+    if (event.data.type === "api") {
+        const { endpoint, serachValue, selectedDictionary } = event.data
+        let response
+        if (serachValue) {
+            response = await fetch(`${endpoint}/getWords?name=${serachValue}&selecteddictionary=${selectedDictionary}`);
+        } else {
+            response = await fetch(`${endpoint}/getData?name=${serachValue}&selecteddictionary=${selectedDictionary}`);
+        }
+        const data = await response.json();
+        self.postMessage({ data });
+    }
+    if (event.data.type === "filterwords") {
+        const { data, serachValue, prefixValue, containsValue, suffixValue, exculdeValue, includeValue, lengthValue, sortingFilter, dictonary } = event.data
+        let newWordsLength = 0;
+        for (let i = 15; i > 0; i--) {
+            let newdata = data.filter((item) => item.length === i);
+            if (prefixValue) {
+                newdata = newdata.filter((item2) =>
+                    item2.startsWith(prefixValue.toLowerCase())
+                );
+            }
+            if (containsValue) {
+                newdata = newdata.filter((item) =>
+                    item.includes(containsValue.toLowerCase())
+                );
+            }
+            if (suffixValue) {
+                newdata = newdata.filter((item) =>
+                    item.endsWith(suffixValue.toLowerCase())
+                );
+            }
+            if (exculdeValue) {
+                let data = [];
+                newdata.map((item) => {
+                    let check = false;
+                    for (let e = 0; e < exculdeValue.length; e++) {
+                        const element = exculdeValue[e].toLowerCase();
+                        if (item.includes(element)) {
+                            check = true;
+                            break;
+                        } else {
+                            check = false;
+                        }
+                    }
+                    if (check === false) {
+                        data.push(item);
+                    }
+                });
+                newdata = data;
+            }
+            if (includeValue) {
+                let data = [];
+                newdata.map((item) => {
+                    let check = false;
+                    for (let e = 0; e < includeValue.length; e++) {
+                        const element = includeValue[e].toLowerCase();
+                        if (!item.includes(element)) {
+                            check = true;
+                            break;
+                        } else {
+                            check = false;
+                        }
+                    }
+                    if (check === false) {
+                        data.push(item);
+                    }
+                });
+                newdata = data;
+            }
+            if (lengthValue) {
+                newdata = newdata.filter((item) => item.length == lengthValue);
+            }
+            // if (newdata.length === 0) {
+            // } else {
+            newWordsLength += newdata.length;
+            newdata = sortWords(sortingFilter, newdata, dictonary);
+            let result = newdata.map((item) => {
+                let itemHtml = "";
+                if (serachValue) {
+                    var text1 = serachValue.replace("?", "");
+                    var text2 = item;
+                    var text3 = item;
+                    let chars = text1.split("");
+                    let indexs = [];
+                    chars.map((i) => {
+                        let findIndexes = findIndex(text3, i);
+                        if (findIndexes.length > 0) {
+                            text3 = text3.split("");
+                            text3[findIndexes] = "$";
+                            text3 = text3.join("");
+                            indexs = [...indexs, ...findIndexes];
+                        }
+                    });
+                    text2.split("").map((itemValue, index) => {
+                        let check = indexs.find((i) => i === index);
+                        if (check !== undefined) {
+                            itemHtml += `${itemValue}`;
+                        } else {
+                            itemHtml += `<span class='highlight'>${itemValue}</span>`;
+                        }
+                    });
+                } else {
+                    itemHtml = item
+                }
+                if (item.length === 1) {
+                    ok = false;
+                    newWordsLength = newWordsLength - 1;
+                } else {
+                    let ScrabbleLetterScore = ScrabbleScore();
+                    sum = 0;
+                    item = item.toLowerCase();
+                    for (let i = 0; i < item.length; i++) {
+                        sum += ScrabbleLetterScore[item[i]] || 0; // for unknown characters
+                    }
+                    return `
+                    <a class="anchor__style" title="Lookup ${item} in Dictionary" target="_blank" href="/word-meaning?search=${item.toLowerCase()}">
+                    ${itemHtml}
+                    <span class="points" value="${sum}" style="position:relative; top:4px; font-size:12px">${sum}</span>
+                    </a>
+                    `;
+                }
+            });
+            result = result.slice(0, 25)
+            self.postMessage({
+                type: "filterwords",
+                prefixValue: prefixValue,
+                containsValue: containsValue,
+                suffixValue: suffixValue,
+                exculdeValue: exculdeValue,
+                includeValue: includeValue,
+                lengthValue: lengthValue,
+                newdata: newdata,
+                i: i,
+                newWordsLength: newWordsLength,
+                result,
+            });
+            // }
+        }
+    }
+};
+
+
+function sortWords(sortingFilter, data, dictonary) {
+    if (sortingFilter == 0) {
+        return data;
+    } else if (sortingFilter == 1) {
+        return data.sort();
+    } else if (sortingFilter == 2) {
+        return data.reverse();
+    } else if (sortingFilter == 3) {
+        var tempArr = [];
+        var newArray = [];
+        data.map((item) => {
+            let newWordsLength = 0;
+            if (item.length === 1) {
+                ok = false;
+                newWordsLength = newWordsLength - 1;
+            } else {
+                let ScrabbleLetterScore = ScrabbleScore(dictonary);
+                let points = 0;
+                item = item.toLowerCase();
+                for (let i = 0; i < item.length; i++) {
+                    points += ScrabbleLetterScore[item[i]] || 0; // for unknown characters
+                }
+                const value = {
+                    words: item,
+                    points: points,
+                };
+                newArray.push(value);
+            }
+        });
+
+        newArray.sort(function (a, b) {
+            return b.points - a.points;
+        });
+
+        newArray.map((ele) => {
+            tempArr.push(ele.words);
+        });
+        return tempArr;
+    }
+}
+// Scrabble Point Array
+const ScrabbleScore = (dictonary) => {
+    let twl06_sowpods = {
+        a: 1,
+        e: 1,
+        i: 1,
+        o: 1,
+        u: 1,
+        l: 1,
+        n: 1,
+        r: 1,
+        s: 1,
+        t: 1,
+        d: 2,
+        g: 2,
+        b: 3,
+        c: 3,
+        m: 3,
+        p: 3,
+        f: 4,
+        h: 4,
+        v: 4,
+        w: 4,
+        y: 4,
+        k: 5,
+        j: 8,
+        x: 8,
+        q: 10,
+        z: 10,
+    };
+    let wwfScore = {
+        a: 1,
+        b: 4,
+        c: 4,
+        d: 2,
+        e: 1,
+        f: 4,
+        g: 3,
+        h: 3,
+        i: 1,
+        j: 10,
+        k: 5,
+        l: 2,
+        m: 4,
+        n: 2,
+        o: 1,
+        p: 4,
+        q: 10,
+        r: 1,
+        s: 1,
+        t: 1,
+        u: 2,
+        v: 5,
+        w: 4,
+        x: 8,
+        y: 3,
+        z: 10,
+    };
+
+    if (dictonary === "wwf") {
+        return wwfScore;
+    } else {
+        return twl06_sowpods;
+    }
+};
+
+function findIndex(str, char) {
+    const strLength = str.length;
+    const indexes = [];
+    let newStr = str;
+
+    while (newStr && newStr.indexOf(char) > -1) {
+        indexes.push(newStr.indexOf(char) + strLength - newStr.length);
+        newStr = newStr.substring(newStr.indexOf(char) + 5);
+        newStr = newStr.substring(newStr.indexOf(char) + 5);
+    }
+
+    return indexes;
+}

data/assets/js/wordfinder.js

@@ -76,7 +76,7 @@ let serachBtn = document.querySelector(".serachBtn")
 let searchBtnContainer = document.querySelector(".search-btn-container")
 
 // getWords define...
-const worker = new Worker('wordfinder-worker.js');
+const worker = new Worker('./assets/js/wordfinder-worker.js');
 const getData = async (serachValue) => {
     try {
         document.querySelector(".main-header").style.background = "#fff"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: word-games-theme
 version: !ruby/object:Gem::Version
-  version: 2.8.0
+  version: 2.8.2
 platform: ruby
 authors:
 - manpreet-appscms
@@ -393,6 +393,7 @@ files:
 - assets/js/wordScrabble-test.js
 - assets/js/wordScrabble.js
 - assets/js/wordfinder-home.js
+- assets/js/wordfinder-worker.js
 - assets/js/wordfinder.js
 - assets/js/wordgames-home.js
 - assets/js/wordgames-result.js