als-document 0.1.1 → 0.5.1

package/query/query.js

@@ -0,0 +1,147 @@
+class Query {
+   static get(query) {
+      let q = new Query(query)
+      return q.selectors
+   }
+
+   constructor(query) {
+      this.query = query
+      this.selectors = []
+      this.getQueries(query.split(','))
+  }
+
+  getQueries(selectors) {
+      selectors.forEach(selector => {
+         let originalSelector = selector
+         selector = this.removeSpaces(selector)
+         this.stringValues = []
+         selector = selector.replace(/\[.*?\]/g,(value) => {
+            this.stringValues.push(value)
+            return `[${this.stringValues.length-1}]`
+         })
+         let [element,ancestors] = this.splitAndCutLast(selector,' ') // \s - ancestor
+         element = this.getFamily(element)
+         if(ancestors.length > 0) 
+            element.ancestors = ancestors.map(ancestor => this.getFamily(ancestor))
+         element.group = originalSelector
+         this.selectors.push(element)
+      });
+   }
+
+   splitAndCutLast(string,splitBy) {
+      let array = string.split(splitBy)
+      let last
+      if(array.length == 1) {
+         last = array[0]
+         array = []
+      } else last = array.splice(array.length-1,array.length-1)[0]
+      return [last,array]
+   }
+
+   getFamily(group,element,prev,prevAny,sign) {
+      if(group.match(/\~|\+/) !== null) {
+         let [last,prevBrothers] = this.splitAndCutLast(group,/\~|\+/)
+         let signs = group.replace(last,'')
+         prevBrothers.forEach(el => signs = signs.replace(el,''))
+         signs = signs.match(/\~|\+/g)
+         if(signs.length == 1) {
+            sign = signs[0]
+         } else if(signs.length > 1){
+            sign = signs.splice(signs.length-1,signs.length-1)[0]
+            prevBrothers[0] = prevBrothers.map((b,i) => {
+               if(i<prevBrothers.length-1) b += signs[i]
+               return b
+            }).join('')
+            prevBrothers[0] = this.getFamily(prevBrothers[0])
+         }
+         if(sign == '~') prevAny = prevBrothers[0] // ~ - any prev brother
+         else if(sign == '+') prev = prevBrothers[0] // + - prev brother
+         element = last
+      } else element = group
+      let family
+      if(prev || prevAny) {
+         family = this.getParents(element)
+         if(prev) family.prev = this.getParents(prev)
+         if(prevAny) family.prevAny = this.getParents(prevAny)
+      } else family = this.getParents(element)
+      if(family.query !== group) family.group = group
+      return family
+   }
+
+   getParents(selector) {
+      if(typeof selector == 'string') {
+         let [element,parents] = this.splitAndCutLast(selector,'>')
+         element = this.buildElement(element)
+         parents = parents.map(parent => this.buildElement(parent))
+         if(parents.length > 0) element.parents = parents
+         return element
+      } else return selector
+   }
+
+
+   buildElement(element,id=null,tag=null,classList=[]) {
+      let query = element
+      element = element.replace(/\#(\w-?)*/,$id => {
+         id = $id.replace(/^\#/,''); return ''
+      })
+      element = element.replace(/\.(\w-?)*/,$class => {
+         classList.push($class.replace(/^\./,'')); return ''
+      })
+      element = element.replace(/(\w-?)*/,$tag => {
+         tag = $tag == '' ? null : $tag; return ''
+      })
+      let attribs = this.getAttributes(element)
+      element = {query}
+      if(id) element.id = id
+      if(tag) element.tag = tag
+      if(classList.length > 0) element.classList = classList
+      if(attribs.length > 0) element.attribs = attribs
+      return element
+   }
+
+   getAttributes(element) {
+      let attribs = this.stringValues.filter((value,index) => {
+         let searchValue = `[${index}]`
+         if(element.match(searchValue)) return true
+         else return false
+      })
+      attribs = attribs.map(attrib => {
+         let query = attrib
+         attrib = attrib.replace('[','').replace(']','')
+         let [name,value] = attrib.split(/[\~\|\^\$\*]?\=/)
+         let sign = attrib.replace(name,'').replace(value,'')
+         attrib = {query}
+         if(name) attrib.name = name
+         if(value) attrib.value = value.trim().replace(/^\"/,'').replace(/\"$/,'')
+         if(sign) {
+            attrib.sign = sign
+            attrib.check = this.getAttribFn(sign).bind(attrib)
+         }
+         return attrib
+      });
+      return attribs
+   }
+
+   getAttribFn(sign) {
+      if(sign == '=') return function(value) {return value == this.value ? true : false}
+      if(sign == '*=') return function(value) {return value.includes(this.value) ? true : false}
+      if(sign == '^=') return function(value) {return value.startsWith(this.value) ? true : false}
+      if(sign == '$=') return function(value) {return value.endsWith(this.value) ? true : false}
+      if(sign == '|=') return function(value) {
+         return value.trim().split(' ').length == 1 
+         && (value.startsWith(this.value) || value.startsWith(this.value+'-')) 
+         ? true : false
+      }
+      if(sign == '~=') return function(value) { // includes whole word only
+         return this.value.trim().split(' ').length == 1 && value.includes(this.value) ? true : false
+      }
+   }
+
+   removeSpaces(selector) {
+      selector = selector.replace(/\s{2}/g,' ') // remove double spaces
+      selector = selector.replace(/\s?\^?\$?\|?\~?\*?\=\s*/g,(m) => m.trim()) // remove spaces inside []
+      selector = selector.replace(/\s?(\+|\~|\>)\s?/g,(m) => m.trim()) // remove spaces around +|~|>
+      return selector
+   }
+}
+try {module.exports = Query} catch {}

package/query/readme.md

@@ -0,0 +1,131 @@
+## Query
+Query is a class for parsing selectors inside html query. Query not supporting pseudo selectors so far.
+You can use Query on frontend and on backend. 
+
+Query can be used on fronten and on backend.
+
+Frontend:
+```html
+<script src="/node_modules/als-document/query/query.js"></script>
+```
+
+Backend:
+```javascript
+let {Query} = require('als-document')
+```
+
+### Syntax
+
+```javascript
+let queryObj = new Query(qeury:string): instanceof Query
+let selectors = queryObj.selectors:string
+// or
+let selectors = Query.get(q1:string):string
+```
+
+``query`` - html/css query
+
+
+### Example 
+
+```javascript
+let q1 = 'html>body>div.tabs~.some[type $= "radio and some"]>p+div>.some-id .tab-content~input[disabled] div.some'
+let result = new Query(q1).selectors
+let result1 = Query.get(q1)
+// result and result1 has to be same
+console.log(result)
+```
+
+Result:
+```javascript
+[
+   {
+      "query": "div.some",
+      "tag": "div",
+      "classList": [
+         "some"
+      ],
+      "ancestors": [
+         {
+            "query": ".some-id",
+            "classList": [
+               "some-id"
+            ],
+            "parents": [
+               {
+                  "query": "div",
+                  "tag": "div"
+               }
+            ],
+            "prev": {
+               "query": "p",
+               "tag": "p",
+               "parents": [
+                  {
+                     "query": ".some[0]",
+                     "classList": [
+                        "some"
+                     ],
+                     "attribs": [
+                        {
+                           check:(f),
+                           "query": "[type$=\"radio and some\"]",
+                           "name": "type",
+                           "value": "radio and some",
+                           "sign": "$="
+                        }
+                     ]
+                  }
+               ],
+               "prevAny": {
+                  "query": "div.tabs",
+                  "tag": "div",
+                  "classList": [
+                     "tabs"
+                  ],
+                  "parents": [
+                     {
+                        "query": "html",
+                        "tag": "html"
+                     },
+                     {
+                        "query": "body",
+                        "tag": "body"
+                     }
+                  ]
+               },
+               "group": "html>body>div.tabs~.some[0]>p"
+            },
+            "group": "html>body>div.tabs~.some[0]>p+div>.some-id"
+         },
+         {
+            "query": "input[1]",
+            "tag": "input",
+            "attribs": [
+               {
+                  "query": "[disabled]",
+                  "name": "disabled"
+               }
+            ],
+            "prevAny": {
+               "query": ".tab-content",
+               "classList": [
+                  "tab-content"
+               ]
+            },
+            "group": ".tab-content~input[1]"
+         }
+      ],
+      "group": "html>body>div.tabs~.some[type $= \"radio and some\"]>p+div>.some-id .tab-content~input[disabled] div.some"
+   }
+]
+```
+
+### Attribs and check function
+if attribute has value, attrib object will contain check function with one parameter for value to check. 
+
+```javascript
+let s = Query.get('[test^="some"]')[0]
+console.log(s.attribs[0].check('some value test')) // true
+```
+

package/query/test.js

@@ -0,0 +1,143 @@
+let Test = require('als-test')
+let {equal,greater,smaller,$greater, $smaller} = Test
+let Query = require('./query')
+
+module.exports = new Test('Query tests',[
+   {
+      title:'Build query',
+      result:function(){
+         this.vars.q1 = 'html>body>div.tabs~.some[type $= "some"][test]>p+div>.some-id .tab-content~input[disabled] div.some'
+         this.vars.s1 = Query.get(this.vars.q1)[0]
+      },
+   },
+   {
+      title:'Check target',
+      expected:'div.some',
+      result:function({s1}){
+         let {tag,classList} = s1
+         return `${tag}.${classList[0]}`
+      },
+      action:equal
+   },
+   {
+      title:'Check ancestors length',
+      expected:2,
+      result:function({s1}){
+         return s1.ancestors.length
+      },
+      action:equal
+   },
+   {
+      title:'Check prev group',
+      expected:function({s1}) {
+         return s1.ancestors[0].group.split('+')[0]
+      },
+      result:function({s1}){
+         return s1.ancestors[0].prev.group
+      },
+      action:equal
+   },
+   {
+      title:'Check parents length',
+      expected:1,
+      result:async function({s1}){
+         return s1.ancestors[0].parents.length
+      },
+      action:equal
+   },
+   {
+      title:'Check prev any, prev and classList',
+      expected:'tabs',
+      result:async function({s1}){
+         return s1.ancestors[0].prev.prevAny.classList[0]
+      },
+      action:equal
+   },
+   {
+      title:'Check attributes length',
+      expected:2,
+      result:async function({s1}){
+         return s1.ancestors[0].prev.parents[0].attribs.length
+      },
+      action:equal
+   },
+   {
+      title:'Check attributes fn $',
+      expected:true,
+      result:async function({s1}){
+         return s1.ancestors[0].prev.parents[0].attribs[0].check('test and some')
+      },
+      action:equal
+   },
+   {
+      title:'Check attributes fn *=',
+      expected:true,
+      result:async function({s1}){
+         return s1.ancestors[0].prev.parents[0].attribs[0].check('some')
+      },
+      action:equal
+   },
+   {
+      title:'Check attributes fn *=',
+      expected:true,
+      result:async function(){
+         let s = Query.get('[test*="some value"]')[0]
+         return s.attribs[0].check('some value test')
+      },
+      action:equal
+   },
+   {
+      title:'Check attributes fn ~= prase instead single word',
+      expected:false,
+      result:async function(){
+         let s = Query.get('[test~="some value"]')[0]
+         return s.attribs[0].check('some value test')
+      },
+      action:equal
+   },
+   {
+      title:'Check attributes fn ~=',
+      expected:true,
+      result:async function(){
+         let s = Query.get('[test~="value"]')[0]
+         return s.attribs[0].check('some value test')
+      },
+      action:equal
+   },
+   {
+      title:'Check attributes fn ^=',
+      expected:true,
+      result:async function(){
+         let s = Query.get('[test^="some"]')[0]
+         return s.attribs[0].check('some value test')
+      },
+      action:equal
+   },
+   {
+      title:'Check attributes fn |= with few words',
+      expected:false,
+      result:async function(){
+         let s = Query.get('[test|="some value test"]')[0]
+         return s.attribs[0].check('some')
+      },
+      action:equal
+   },
+   {
+      title:'Check attributes fn |=word',
+      expected:true,
+      result:async function(){
+         let s = Query.get('[test|="some"]')[0]
+         return s.attribs[0].check('some')
+      },
+      action:equal
+   },
+   {
+      title:'Check attributes fn |=word-word',
+      expected:true,
+      result:async function(){
+         let s = Query.get('[test|="some"]')[0]
+         return s.attribs[0].check('some-value')
+      },
+      action:equal
+   },
+])