word-games-theme 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1fac7816d22aa585e1597a8162ec27c4cc146c649bd88f283091800f1380bd0e
-  data.tar.gz: e62e8a2388d6e56b3c5c9d582843ce7fa6b32e33a2fbadd2ceeb0c24454c7f91
+  metadata.gz: 8b9f7f8f2001ad497331a46b4cdd012220890886f94346fb468b99c4ff0fe79e
+  data.tar.gz: 02aef104d5ccfa527fbb16fa85217a251befcfb888d985f87e5662bdb15c4e35
 SHA512:
-  metadata.gz: 5e2dc7d5ca132feb8d67959d67af337e19eab6f28d3e086a27a6290f4a1d3647bc0717e2d79f1c99dc066a662652a5be132ddb24f004fa1820a121fa8f39c565
-  data.tar.gz: 6e66fedaf884043783417ba4f23f5ff0bceb6d90ade729040406558dc5b92c9e693688dabd98c4aa929b5c1ea60370f81a81b77719097e62cb87516065359128
+  metadata.gz: ed8c70fa2e14defcb4f9b5f8b7d67d0f9087919bf36e8ab5056e5eca2b26879c3ec4eeb63145653ce5a4bb92db2cb18db9bbeed81d3a250f2bb395ccd35ab27a
+  data.tar.gz: 1521f85c30aa87f9755f269e50239179516b83cffd5da1e4d2efe657103b7adfcefce064feefa340e0bec303033722c986ba291258791cfe417a44d3458f8f25

data/assets/css/advancedFilter.css

@@ -162,7 +162,7 @@ a {
     right: auto;
     position: fixed;
     left: 0px;
-    top: 0px;
+    top: 135px;
     width: 100%;
   }
   .filter_count {

data/assets/css/home.css

@@ -4,11 +4,12 @@
   flex-direction: column;
   justify-content: center;
   align-items: center;
-  height: 50vh;
+  height: auto;
   background: url(../images/bg_elements.png);
   background-position: center;
   background-size: cover;
   margin-bottom: 20vh;
+  padding:15px 0;
 }
 .result_navbar_section{
   width: 100%;
@@ -323,9 +324,6 @@ input:-webkit-autofill:active {
   .result_navbar_section{
     padding: 1.2rem 15px !important;
  }
- .pageHeaderBg{
-   height: 300px;
- }
  .pageHeading{
    margin-bottom: 1rem;
  }

data/assets/css/style.css

@@ -28,15 +28,18 @@ html {
 /* loader css close */
 header {
   width: 100%;
-  position: relative;
+  position: sticky;
+  top: 0;
+  left: 0;
+  z-index: 999; 
 }
 .navbar {
   width: 100%;
   padding: 1.2rem 9% !important;
-  position: fixed;
+  /* position: fixed;
   top: 0;
   left: 0;
-  z-index: 999;
+  z-index: 999; */
   display: flex;
   justify-content: space-between;
   flex-wrap: wrap;
@@ -244,8 +247,8 @@ header {
 }
 
 .tools_headings {
-  margin-top: 110px;
-  margin-bottom: 20px;
+ padding: 15px 0;
+
 }
 .how-to-section {
   padding: 90px 0;

data/assets/js/test.js

@@ -0,0 +1,763 @@
+/***************
+ SCRABBLER_JS
+***************/
+
+// grab some html elements
+
+
+const getScript = document.currentScript
+let form = document.querySelector('.resultPageSearchBtn')
+let wordCount = document.querySelector('.wordCount')
+let main = document.querySelector('.main')
+let errorMsg = document.querySelector('.errorMsg')
+let script = document.currentScript
+
+// getqueryUrl from form
+const params = new URLSearchParams(window.location.search)
+let serachValue = params.get('search').toLowerCase()
+let prefixValue = params.get('prefix')
+let containsValue = params.get('contains')
+let suffixValue = params.get('suffix')
+let exculdeValue = params.get('exculde')
+let includeValue = params.get('include')
+let lengthValue = params.get('length')
+let dictonary = params.get('dictionary')
+
+// advanced filter element grabs
+let tick
+let startsWith = document.getElementById('startsWith')
+let mustInclude = document.getElementById('mustInclude')
+let endsWith = document.getElementById('endsWith')
+let exculdeWith = document.getElementById('exculdeWith')
+let inculdeWith = document.getElementById('inculdeWith')
+let wordLength = document.getElementById('wordLength')
+
+let ok = true
+
+let tab_container = document.querySelector('.tab_container')
+const siteUrl = getScript.dataset.url
+var sortValue
+var sortBool = false
+
+
+let letterCloseButton = document.querySelector('.letter-close-button-commonPage')
+if (serachValue) {
+    letterCloseButton.classList.add("ltr-cls-btn-commonPage")
+}
+letterCloseButton.addEventListener("click", () => {
+    txtBox.value = ""
+    letterCloseButton.classList.remove("ltr-cls-btn-commonPage")
+})
+
+
+let txtBox = document.querySelector('.txtBox')
+txtBox.focus()
+txtBox.value = serachValue
+txtBox.addEventListener('input', (e) => {
+    if (e.target.value === "") {
+        letterCloseButton.classList.remove("ltr-cls-btn-commonPage")
+    } else {
+        letterCloseButton.classList.add("ltr-cls-btn-commonPage")
+    }
+    let rangeOfBlankTile = script.dataset.range
+    e.target.value = e.target.value.replace(/[^a-zA-Z? ]/g, '')
+    if (rangeOfBlankTile === '') {
+        rangeOfBlankTile = 3
+    }
+    e.target.value = e.target.value.replace(/ /g, '?')
+    let data = []
+    data = e.target.value.split('').filter((i) => i === '?')
+    if (data.length > rangeOfBlankTile) {
+        e.target.value = e.target.value.replace(/\?$/, '')
+    }
+})
+var theSelect = document.getElementById('select_dropDown')
+
+const sortup = document.querySelector(".sortup-icon")
+let bool = false
+sortup.addEventListener("click", () => {
+    if (bool) {
+        theSelect.size = 0
+        bool = false
+        theSelect.style.display = "none"
+    }
+    else {
+        bool = true
+        theSelect.size = 3
+        theSelect.style.display = "block"
+    }
+})
+document.querySelector('.select_dropDown2').value = dictonary
+const getDiff = (text1, text2) => {
+    var diffRange = []
+    var currentRange = undefined
+    for (var i = 0; i < text1.length; i++) {
+        if (text1[i] != text2[i]) {
+            if (currentRange == undefined) {
+                currentRange = [i]
+            }
+        }
+        if (currentRange != undefined && text1[i] == text2[i]) {
+            currentRange.push(i)
+            diffRange.push(currentRange)
+            currentRange = undefined
+        }
+    }
+    if (currentRange != undefined) {
+        currentRange.push(i)
+        diffRange.push(currentRange)
+    }
+    return diffRange
+}
+// getWords define...
+const getData = async (serachValue) => {
+    try {
+
+        let selectedDictionary = document.querySelector('.select_dropDown2').value
+        main.innerHTML = `<div class="loader">
+    <img src='/assets/images/loading.gif'>
+    <div style="font-weight:900;font-size:14px" >Finding words - Powered by ${siteUrl.replace(/^https?:\/\//, '')}</div>
+    </div>`
+        /// loader
+        const response = await fetch(
+            `http://127.0.0.1:9000/getWords?name=${serachValue}&selecteddictionary=${selectedDictionary}`
+        )
+        const data = await response.json()
+        main.innerHTML = ''
+        console.log(data)
+        getWords(data)
+        //getWords calling...
+    } catch (error) {
+        console.log(error)
+    }
+}
+//getData calling...
+if (lengthValue === '1') {
+    errorMsg.innerHTML = 'words length should be more than 1'
+} else {
+    getData(serachValue.toLowerCase())
+    form.addEventListener("click", (e) => {
+        main.innerHTML = ''
+        console.log("clicked")
+        e.preventDefault()
+        getData(txtBox.value.toLowerCase())
+    })
+
+}
+
+
+
+
+// getWords function define...
+function getWords(data) {
+    if (typeof data === 'string') {
+        errorMsg.innerHTML = 'no words found'
+        wordCount.innerHTML = `<strong>Found 0 words with letters ${serachValue.split(
+            ''
+        )}</strong>`
+    } else {
+        let newWordsLength = 0
+
+        // sort eventlistener
+        theSelect.addEventListener('change', () => {
+            sortValue = theSelect[theSelect.selectedIndex].text
+            if (sortValue == 'Z-A') {
+                sortBool = true
+                sortby(sortBool, data)
+            } else {
+                sortBool = false
+                sortby(sortBool, data)
+            }
+            if (sortValue == 'Points') {
+                sortBool = true
+                sortPointsby(sortBool, data)
+            }
+        })
+
+        for (let i = serachValue.length; i >= 1; i--) {
+            let newdata = data.filter((item) => item.length === i)
+
+            if (prefixValue) {
+                newdata = newdata.filter((item2) =>
+                    item2.startsWith(prefixValue.toLowerCase())
+                )
+                startsWith.classList.add('tick')
+                startsWith.value = prefixValue
+            }
+            if (containsValue) {
+                newdata = newdata.filter((item) =>
+                    item.includes(containsValue.toLowerCase())
+                )
+                mustInclude.classList.add('tick')
+                mustInclude.value = containsValue
+            }
+            if (suffixValue) {
+                newdata = newdata.filter((item) =>
+                    item.endsWith(suffixValue.toLowerCase())
+                )
+                endsWith.classList.add('tick')
+                endsWith.value = suffixValue
+            }
+
+            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)
+                    }
+                })
+                exculdeWith.classList.add('tick')
+                exculdeWith.value = exculdeValue
+                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)
+                    }
+                })
+                inculdeWith.classList.add('tick')
+                inculdeWith.value = includeValue
+                newdata = data
+            }
+
+            if (lengthValue) {
+                newdata = newdata.filter((item) => item.length == lengthValue)
+                wordLength.classList.add('tick')
+                wordLength.value = lengthValue
+            }
+
+            if (newdata.length === 0) {
+                main.innerHTML += ''
+            } else {
+                newWordsLength += newdata.length
+                const result = newdata.map((item) => {
+                    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]
+                        }
+                    })
+                    let itemHtml = ''
+                    text2.split('').map((itemValue, index) => {
+                        let check = indexs.find((i) => i === index)
+
+                        if (check !== undefined) {
+                            itemHtml += `${itemValue}`
+                        } else {
+                            itemHtml += `<span class='highlight'>${itemValue}</span>`
+                        }
+                    })
+
+                    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()}">
+            <li>${itemHtml}
+          <span class="points" value="${sum}" style="position:relative; top:4px; font-size:12px"> ${sum}</span>
+            </li></a>`
+                    }
+                })
+
+                if (ok) {
+                    tab_container.innerHTML += `
+          <input type="button" id="Tab_${i}" onclick="Filtering(${i})" value="${i} Letter"
+          class="tab_link  cursorPointer" />
+          `
+                    let tabs = document.getElementsByClassName('tab_link')
+                    tabs[0] ? tabs[0].classList.add('active-tab') : ''
+                    main.innerHTML += `
+          <div class="allGroupWords wordlistContainer" id="alpha_${i}">
+              <div class="wordListHeading">
+                  <h3 class="lead">${i} Letter Words</h3>
+              </div>
+              <div class="wordList">
+                  <ul class="ul list-unstyled">
+                   ${result.join('')}
+                  </ul>
+              </div>
+          </div>
+          `
+                }
+            }
+        }
+
+        if (newWordsLength === 0) {
+            errorMsg.innerHTML = 'no words found'
+        } else {
+            wordCount.innerHTML = `<strong>Found ${newWordsLength} words with letters with ${serachValue.split(
+                ''
+            )}</strong>`
+        }
+    }
+}
+
+// sorting by points
+function sortPointsby(sortValue, data) {
+    main.innerHTML = ''
+    if (sortValue) {
+        let newWordsLength = 0
+        for (let i = serachValue.length; i >= 1; i--) {
+            var newdata = data.filter((item) => item.length === i)
+
+            if (newdata.length === 0) {
+                main.innerHTML += ''
+            } else {
+                newWordsLength += newdata.length
+                var newArray = []
+                newdata.map((item) => {
+                    if (item.length === 1) {
+                        ok = false
+                        newWordsLength = newWordsLength - 1
+                    } else {
+                        let ScrabbleLetterScore = ScrabbleScore()
+                        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
+                })
+
+                const result = newArray.map((item) => {
+                    var text1 = serachValue.replace('?', '')
+                    var text2 = item.words
+                    var text3 = item.words
+
+
+                    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) + 1)
+                            newStr = newStr.substring(newStr.indexOf(char) + 1)
+                        }
+                        return indexes
+                    }
+                    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]
+                        }
+                    })
+                    let itemHtml = ''
+                    text2.split('').map((itemValue, index) => {
+                        let check = indexs.find((i) => i === index)
+                        if (check !== undefined) {
+                            itemHtml += `${itemValue}`
+                        } else {
+                            itemHtml += `<span class='highlight'>${itemValue}</span>`
+                        }
+                    })
+                    return `<a class="anchor__style" title="Lookup ${item} in Dictionary" target="_blank" href="/word-meaning?search=${item.words}">
+          <li>${itemHtml}
+        <span class="points" value="${item.points}" style="position:relative; top:4px; font-size:12px"> ${item.points}</span>
+          </li></a>`
+                })
+
+                main.innerHTML += `
+        <div class="allGroupWords wordlistContainer" id="alpha_${i}">
+            <div class="wordListHeading">
+                <h3 class="lead">${i} Letter Words</h3>
+            </div>
+            <div class="wordList">
+                <ul class="ul list-unstyled">
+                 ${result.join('')}
+                </ul>
+            </div>
+        </div>
+        `
+            }
+        }
+    }
+}
+
+// sort by aplhabets
+function sortby(sortBool, data) {
+    if (sortBool) {
+        main.innerHTML = ''
+        data.reverse()
+        let newWordsLength = 0
+        for (let i = serachValue.length; i >= 1; i--) {
+            var newdata = data.filter((item) => item.length === i)
+
+            if (newdata.length === 0) {
+                main.innerHTML += ''
+            } else {
+                newWordsLength += newdata.length
+
+                const result = newdata.map((item) => {
+                    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]
+                        }
+                    })
+                    let itemHtml = ''
+                    text2.split('').map((itemValue, index) => {
+                        let check = indexs.find((i) => i === index)
+                        if (check !== undefined) {
+                            itemHtml += `${itemValue}`
+                        } else {
+                            itemHtml += `<span class='highlight'>${itemValue}</span>`
+                        }
+                    })
+                    if (item.length === 1) {
+                        ok = false
+                        newWordsLength = newWordsLength - 1
+                    } else {
+                        let ScrabbleLetterScore = ScrabbleScore()
+                        let 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()}">
+            <li>${itemHtml}
+        <span class="points" value="${sum}" style="position:relative; top:4px; font-size:12px"> ${sum}</span>
+          </li></a>`
+                    }
+                })
+
+                main.innerHTML += `
+        <div class="allGroupWords wordlistContainer" id="alpha_${i}">
+            <div class="wordListHeading">
+                <h3 class="lead">${i} Letter Words</h3>
+            </div>
+            <div class="wordList">
+                <ul class="ul list-unstyled">
+                 ${result.join('')}
+                </ul>
+            </div>
+        </div>
+        `
+            }
+        }
+    } else {
+        main.innerHTML = ''
+        data.sort()
+        for (let i = serachValue.length; i >= 1; i--) {
+            var newdata = data.filter((item) => item.length === i)
+            if (newdata.length === 0) {
+                main.innerHTML += ''
+            } else {
+                const result = newdata.map((item) => {
+                    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]
+                        }
+                    })
+                    let itemHtml = ''
+                    text2.split('').map((itemValue, index) => {
+                        let check = indexs.find((i) => i === index)
+                        if (check !== undefined) {
+                            itemHtml += `${itemValue}`
+                        } else {
+                            itemHtml += `<span class='highlight'>${itemValue}</span>`
+                        }
+                    })
+                    if (item.length === 1) {
+                        ok = false
+                    } else {
+                        let ScrabbleLetterScore = ScrabbleScore()
+                        let 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()}">
+            <li>${itemHtml}
+        <span class="points" value="${sum}" style="position:relative; top:4px; font-size:12px"> ${sum}</span>
+          </li></a>`
+                    }
+                })
+                main.innerHTML += `
+        <div class="allGroupWords wordlistContainer" id="alpha_${i}">
+            <div class="wordListHeading">
+                <h3 class="lead">${i} Letter Words</h3>
+            </div>
+            <div class="wordList">
+                <ul class="ul list-unstyled">
+                 ${result.join('')}
+                </ul>
+            </div>
+        </div>
+        `
+            }
+        }
+    }
+}
+
+// Scrabble Point Array
+const ScrabbleScore = () => {
+    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
+    }
+}
+
+//Handling of filter counter in advanced filter
+function addFilterCount() {
+    let filter_val = document.getElementsByClassName('filter_val')
+    let filter = document.querySelector('.filter_count')
+    let filter_count = 0
+
+    filter_val[0].value = prefixValue
+    filter_val[1].value = containsValue
+    filter_val[2].value = suffixValue
+    filter_val[3].value = exculdeValue
+    filter_val[4].value = includeValue
+    filter_val[5].value = lengthValue
+
+    for (var i = 0; i <= 4; i++) {
+        if (filter_val[i].value != '') {
+            filter_count += 1
+        }
+        if (filter_count === 0) {
+            filter.style.display = 'none'
+        } else {
+            filter.style.display = 'inline-block'
+        }
+
+        filter.innerHTML = filter_count
+    }
+}
+addFilterCount()
+
+// handling of filter on scroll
+window.onscroll = function () {
+    var section = document.querySelectorAll('.wordlistContainer')
+    let new_sections = {}
+    Array.prototype.forEach.call(section, function (e) {
+        if (document.body.clientWidth > 991) {
+            new_sections[e.id] = e.offsetTop - 10
+        } else {
+            new_sections[e.id] = e.offsetTop - 10
+        }
+    })
+    var scrollPosition =
+        document.documentElement.scrollTop || document.body.scrollTop
+    for (i in new_sections) {
+        let sort_val = document.querySelector('.sort-select').value
+        if (
+            i.split('_')[0] == sort_val &&
+            new_sections[i] &&
+            new_sections[i] <= scrollPosition
+        ) {
+            document.querySelector('.active-tab').classList.remove('active-tab')
+            var active_now = document.querySelector('#Tab_' + i.split('_')[1])
+            active_now.classList.add('active-tab')
+            active_now.scrollIntoView({ block: 'nearest' })
+        }
+    }
+}
+
+// Add Filtering
+let sections = {}
+function Filtering(id) {
+    let tabs = document.getElementsByClassName('tab_link')
+    tabs[0] ? tabs[0].classList.add('active-tab') : ''
+
+    Array.from(tabs).map((item) => {
+        item.classList.remove('active-tab')
+    })
+    main.innerHTML += ``
+    let activeLetter = event.target
+    activeLetter.classList.add('active-tab')
+
+
+    var section = document.querySelectorAll('.wordlistContainer')
+    var sort_val = document.querySelector('.sort-select').value
+    Array.prototype.forEach.call(section, function (e) {
+        if (document.body.clientWidth > 991) {
+            sections[e.id] = e.offsetTop - 10
+        } else {
+            sections[e.id] = e.offsetTop - 10
+        }
+    })
+
+    document.body.scrollTop = sections[sort_val + '_' + id] + 5
+}
+
+// next && previous functionality
+let prev = document.getElementById('prev')
+let next = document.getElementById('next')
+
+if (prev) {
+    prev.onclick = scroll_Right
+}
+if (next) {
+    next.onclick = scroll_Left
+}
+window.addEventListener('resize', function () {
+    scroll_visible()
+})
+window.addEventListener('scroll', function () {
+    scroll_visible()
+})
+function scroll_visible() {
+    let tab_container = document.querySelector('#tab-container')
+    if (tab_container) {
+        if (tab_container.clientWidth === tab_container.scrollWidth) {
+            prev.style.display = 'none'
+            next.style.display = 'none'
+        } else {
+            prev.style.display = 'block'
+            next.style.display = 'block'
+        }
+    }
+}
+scroll_visible()
+
+function scroll_Left() {
+    tab_container.scrollLeft += 130
+}
+function scroll_Right() {
+    tab_container.scrollLeft -= 130
+}
+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
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: word-games-theme
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.1
 platform: ruby
 authors:
 - manpreet-appscms
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-11 00:00:00.000000000 Z
+date: 2022-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -248,6 +248,7 @@ files:
 - assets/js/advancedFilter3.js
 - assets/js/other-lang-wordScrabble.js
 - assets/js/scrabbleDictonary.js
+- assets/js/test.js
 - assets/js/wordScrabble.js
 - assets/js/wordleSolver.js
 - assets/js/words-in-certain-positions.js