als-document 0.12.0 → 1.0.0-alpha

package/src/node/single-node.js

@@ -0,0 +1,30 @@
+class SingleNode extends Node {
+   constructor(tagName, attributes = {}, parent = null) {
+      if(attributes['?'] && tagName === '?xml') delete attributes['?']
+      super(tagName, attributes, parent);
+      this.isSingle = true
+   }
+   
+   get outerHTML() { // Переопределение outerHTML для одиночного узла
+      if (this.tagName === "#cdata-section") return `<![CDATA[${this.textContent}]]>`;
+      const attrs = Object.entries(this.attributes).map(([key, val]) => `${key}="${val}"`).join(" ");
+      return `<${this.tagName} ${attrs}${this.tagName === '?xml' ? '?' : ''}>`;
+   }
+   // Удаляем методы и свойства, которые не имеют смысла для одиночных узлов
+   get innerHTML() { return ""; }
+   set innerHTML(_) { }
+   $(_) {return null}
+   $$(_) {return []}
+   querySelectorAll(_) { return []; }
+   querySelector(_) { return null; }
+   getElementsByClassName(_) { return []; }
+   getElementsByTagName(_) { return []; }
+   getElementById(_) { return null; }
+   get children() { return []; }
+   insertAdjacentElement(_, __) { }
+   insertAdjacentHTML(_, __) { }
+   insertAdjacentText(_, __) { }
+   appendChild(_) { }
+   get textContent() { return ""; }
+   set textContent(_) { }
+}

package/src/node/style.js

@@ -0,0 +1,26 @@
+function buildStyle(attributes) {
+   const styles = attributes.style || "";
+   
+   const camelToKebab = str => str.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, '$1-$2').toLowerCase();
+   const kebabToCamel = str => str.replace(/-([a-z])/g, g => g[1].toUpperCase());
+
+   const baseStyleObj = styles.split(";").reduce((acc, style) => {
+      const [key, value] = style.split(":").map(s => s.trim());
+      if (key && value) acc[kebabToCamel(key)] = value;
+      return acc;
+   }, {});
+
+   return new Proxy(baseStyleObj, {
+      get: (obj, prop) => obj[camelToKebab(prop)] || obj[prop],
+      set: (obj, prop, value) => {
+         obj[camelToKebab(prop)] = value;
+         attributes.style = Object.entries(obj).map(([k, v]) => `${camelToKebab(k)}: ${v}`).join("; ");
+         return true;
+      },
+      deleteProperty: (obj, prop) => {
+         delete obj[camelToKebab(prop)];
+         attributes.style = Object.entries(obj).map(([k, v]) => `${camelToKebab(k)}: ${v}`).join("; ");
+         return true;
+      }
+   });
+}

package/src/node/text-node.js

@@ -0,0 +1,9 @@
+class TextNode {
+   constructor(data) {
+      this.nodeName = '#text';
+      this.parent = null;
+      this.textContent = data;
+   }
+   get nodeValue() {return this.textContent}
+   get parentNode() {return this.parent}
+}

package/src/parse/parse-atts.js

@@ -0,0 +1,36 @@
+function parseAttributes(str) {
+   const attrs = {};
+   let key = "";
+   let value = "";
+   let isKey = true;
+   let quoteChar = null;
+
+   for (let i = 0; i < str.length; i++) {
+      const char = str[i];
+
+      if (isKey && (char === '=' || char === ' ')) {
+         if (char === '=') isKey = false;
+         else if (key.trim()) { // We've found an attribute without a value
+            attrs[key.trim()] = true;  // Set the value to true for boolean attributes
+            key = ""; // Reset the key
+         }
+         continue;
+      }
+
+      if (!quoteChar && (char === '"' || char === "'")) {
+         quoteChar = char;
+         continue;  // we skip the quote itself
+      } else if (quoteChar && char === quoteChar) {
+         quoteChar = null;
+         attrs[key.trim()] = value.trim();
+         key = ""; value = ""; isKey = true;
+         continue;
+      }
+
+      if (isKey) key += char;
+      else value += char;
+   }
+   
+   if (key.trim() && !value) attrs[key.trim()] = true; // After the loop, check if there's a leftover key, which would be an attribute without a value
+   return attrs;
+}

package/src/parse/parser.js

@@ -0,0 +1,74 @@
+function parseHTML(html) {
+   const root = new Node("ROOT");
+   const stack = [root];
+   let currentText = "", i = 0;
+
+   function parseSpecial(startStr, endStr, n1, n2, tag) {
+      if (!html.startsWith(startStr, i)) return false
+      const end = html.indexOf(endStr, i + n1);
+      const strNode = new Node(tag, {}, stack[stack.length - 1]);
+      strNode.childNodes.push(html.substring(i + n1, end));
+      i = end + n2;
+      return true
+   }
+
+   while (i < html.length) {
+      if (parseSpecial("<!--", "-->", 4, 3, '#comment')) continue
+      if (parseSpecial("<script", "</script>", 8, 9, 'script')) continue
+      if (parseSpecial("<style", "</style>", 7, 8, 'style')) continue
+
+      if (html.startsWith("<![CDATA[", i)) {
+         const end = html.indexOf("]]>", i + 9);
+         if (end === -1) break;  // Убедитесь, что существует закрывающий тег
+         const content = html.substring(i + 9, end); // это содержимое CDATA
+         const cdataNode = new SingleNode("#cdata-section", {}, stack[stack.length - 1]);
+         cdataNode.nodeValue = content;
+         i = end + 3;
+         continue;
+      }
+
+      if (html.startsWith("<", i)) {
+         if (currentText.trim()) {
+            stack[stack.length - 1].childNodes.push(new TextNode(currentText.trim()));
+            currentText = "";
+         }
+
+         let tagEnd = i + 1;
+         let insideQuotes = false;
+         let quoteChar = null;
+
+         while (tagEnd < html.length) {
+            const char = html[tagEnd];
+            if (!insideQuotes && (char === '"' || char === "'")) {
+               insideQuotes = true;
+               quoteChar = char;
+            } else if (insideQuotes && char === quoteChar) {
+               insideQuotes = false;
+               quoteChar = null;
+            }
+
+            if (!insideQuotes && char === '>') break;
+            tagEnd++;
+         }
+
+         const tagContent = html.substring(i + 1, tagEnd);
+
+         if (tagContent.startsWith("/")) stack.pop(); // It is close tag
+         else { // It is open tag
+            let isSelfClosing = tagContent.endsWith('/');
+            const tagNameEnd = tagContent.search(/\s|>|\//); // add a check for "/"
+            const tagName = tagContent.substring(0, tagNameEnd > 0 ? tagNameEnd : tagEnd - i - 1);
+            const attributesString = tagContent.substring(tagName.length, isSelfClosing ? tagContent.length - 1 : tagContent.length).trim();
+            const attributes = parseAttributes(attributesString);
+            if (VOID_TAGS.has(tagName.toLowerCase()) || isSelfClosing) new SingleNode(tagName, attributes, stack[stack.length - 1])
+            else stack.push(new Node(tagName, attributes, stack[stack.length - 1]));
+         }
+         i = tagEnd + 1;
+      } else {
+         currentText += html[i];
+         i++;
+      }
+   }
+   if (currentText.trim()) stack[stack.length - 1].childNodes.push(new TextNode(currentText.trim()));
+   return root;
+}

package/src/parse/void-tags.js

@@ -0,0 +1,5 @@
+const VOID_TAGS = new Set([
+   "area", "base", "br", "col", "command", "embed", "hr", "img", "input",
+   "keygen", "link", "meta", "param", "source", "track", "wbr",
+   "!doctype",'?xml'
+]);

package/src/query/check-element.js

@@ -0,0 +1,84 @@
+function checkElement(el,selector) {
+   if(selector == undefined) return true
+   if(el == null) return false
+   let {tag,classList,attributes,id,prev,ancestors,parents,prevAny} = selector
+   if(typeof el === 'string') return false
+   if(el.isSpecial) return false
+   if(id !== undefined && el.id === null) return false
+   if(id && id !== el.id) return false
+   if(tag && el.tagName === undefined) return false
+   else if(tag && tag !== el.tagName) return false
+   const clas = el.attributes.class
+   if(classList !== undefined && (clas === undefined || clas === '')) return false
+   else if(classList !== undefined) {
+      if(classList.every(e => el.classList.contains(e)) === false) return false
+   }
+   if(checkattributes(attributes,el) === false) return false
+   if(checkElement(el.prev,prev) === false) return false
+   if(checkAncestors(el.ancestors,ancestors) === false) return false
+   if(checkParents(el.ancestors,parents) === false) return false
+   if(el.parent) {
+      if(checkPrevAny(el.parent.children,el.childIndex,prevAny) == false) return false
+   }
+   return true
+}
+
+function checkattributes(attributes=[],el) {
+   let elattributes = el.attributes
+   let names = Object.keys(elattributes)
+   let passedTests = 0
+   if(attributes) for(let i=0; i<attributes.length; i++) {
+      let {name,value,check} = attributes[i]
+      if(name == 'inner' && value !== undefined && check && el.inner) {
+         if(check(el.inner)) passedTests++
+      }
+      
+      if(!names.includes(name)) continue
+      else if(value == undefined) passedTests++
+      else if(value && elattributes[name]) {
+         if(check(elattributes[name]) == false) continue
+         else passedTests++
+      } 
+   }
+   if(passedTests == attributes.length) return true
+   else return false
+}
+
+function checkPrevAny(children=[],index,prevAny) {
+   let size = children.length
+   if((size == 0 || index == 0) && prevAny) return false
+   for(let i=index; i>=0; i--) {
+      if(checkElement(children[i],prevAny)) return true
+   }
+   return false
+}
+
+function checkAncestors(ancestors=[],selectorAncestors=[]) {
+   let count = 0
+   if(selectorAncestors.length == 0) return true
+   let endIndex = ancestors.length-1
+   let selectorIndex = selectorAncestors.length-1
+   while(selectorIndex>=0) {
+      for(let i=endIndex; i>=0; i--) {
+         endIndex=i-1
+         if(checkElement(ancestors[i],selectorAncestors[selectorIndex]) == true) {
+            count++
+            break
+         }
+      }
+      selectorIndex--
+   }
+   if(count == selectorAncestors.length) return true
+   else return false
+}
+
+function checkParents(ancestors=[],selectorParents=[]) {
+   if(selectorParents.length === 0) return true
+   if(ancestors.length < selectorParents.length) return false
+   let index = ancestors.length-1
+   for(let i=selectorParents.length-1; i>=0; i--) {
+      if(checkElement(ancestors[index],selectorParents[i]) === false) return false
+      index--
+   }
+   return true
+}

package/src/query/query.js

@@ -0,0 +1,142 @@
+class Query {
+   static get(query) {
+      let q = new Query(query)
+      return q.selectors
+   }
+
+   constructor(query) {
+      this.query = query
+      this.selectors = []
+      this.stringValues = [];
+      this.parseSelectors(query.split(','))
+   }
+
+   parseSelectors(selectors) {
+      selectors.forEach(selector => {
+         let originalSelector = selector.trim()
+         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) {
+      const array = string.split(splitBy);
+      const last = array.pop(); // pop() удаляет и возвращает последний элемент массива
+      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 }
+      if (sign == '*=') return function (value) { return value.includes(this.value) }
+      if (sign == '^=') return function (value) { return value.startsWith(this.value) }
+      if (sign == '$=') return function (value) { return value.endsWith(this.value) }
+      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
+   }
+}