npm - als-document - Versions diffs - 1.0.7-alpha → 1.0.8-alpha - Mend

als-document 1.0.7-alpha → 1.0.8-alpha

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/src/parse/cache.js ADDED Viewed

@@ -0,0 +1,33 @@
+function buildFromCache(cached) {
+   function buildNode(cache,parent=null) {
+      if(typeof cache === 'string') return parent.childNodes.push(cache)
+      const {isSingle,tagName,attributes,childNodes,textContent} = cache
+      if(textContent) return parent.childNodes.push(new TextNode(textContent))
+      if(isSingle) return parent.childNodes.push(new SingleNode(tagName,attributes))
+      const newDoc = new Node(tagName,attributes,parent)
+      childNodes.forEach(childNode => {
+         buildNode(childNode,newDoc)
+      });
+      return newDoc
+   }
+   return buildNode(cached)
+}
+function cacheDoc(doc) {
+   const props = ['isSingle','tagName','attributes']
+   function addToCache(element,cache={}) {
+      if(typeof element === 'string') return element
+      if(element.nodeName === '#text') return {textContent:element.textContent}
+      props.forEach(prop => {
+         if(element[prop]) cache[prop] = element[prop]
+      });
+      if(!element.childNodes) return cache
+      cache.childNodes = []
+      element.childNodes.forEach(childNode => {
+         cache.childNodes.push(addToCache(childNode))
+      });
+      return cache
+   }
+   return addToCache(doc)
+}

package/src/parse/parse-atts.js CHANGED Viewed

@@ -31,6 +31,6 @@ function parseAttributes(str) {
       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
+   if (key.trim() && !value) attrs[key.trim()] = ''; // After the loop, check if there's a leftover key, which would be an attribute without a value
    return attrs;
 }

package/tests/cache.js ADDED Viewed

@@ -0,0 +1,19 @@
+function mesureTime(fn) {
+   let time = performance.now()
+   const result = fn()
+   time = performance.now() - time
+   return {result,time}
+}
+describe('Cache and build from cache', () => {
+   const {result:root,time:rootTime} = mesureTime(() => parseHTML(html1))
+   const {result:cache,time:cacheTime} = mesureTime(() => cacheDoc(root))
+   const {result:root1,time:root1Time} = mesureTime(() => buildFromCache(cache))
+   it('HTML from cache and HTML from not cached same',() => {
+      console.log({rootTime,cacheTime,root1Time})
+      assert(cacheTime < 5,'Build cache takes less then 5ms')
+      assert(root1Time < 5,'Build DOM from cache takes less then 5ms')
+      assert(root.innerHTML === root1.innerHTML)
+   })
+})

package/tests/index.html CHANGED Viewed

@@ -4,13 +4,13 @@
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
-   <script src="/node_modules/als-simple-test/test.js"></script>
+   <script src="test.js"></script>
    <script src="../document.js"></script>
-   <!-- <script src="./data/html1.js"></script> -->
-   <script src="./data/html2.js"></script>
+   <script src="./data/html1.js"></script>
+   <!-- <script src="./data/html2.js"></script> -->
    <script src="./data/svg.js"></script>
    <script>
-      const { parseHTML, Node, Query, TextNode, SingleNode } = alsDocument
+      const { parseHTML, Node, Query, TextNode, SingleNode, buildFromCache, cacheDoc } = alsDocument
       let {describe,it,beforeEach,runTests,expect,delay,assert,beforeAll} = SimpleTest
       SimpleTest.showFullError = true
    </script>
@@ -18,6 +18,7 @@
    <script src="./query.js"></script>
    <script src="parser.js"></script>
    <script src="node.js"></script>
+   <script src="./cache.js"></script>
 </head>
 <body>
    <script src="parse-real.js"></script>

package/tests/test.js ADDED Viewed

@@ -0,0 +1,169 @@
+class SimpleTest {
+   static tests = [];
+   static beforeEachCallback;
+   static afterEachCallback;
+   static nestingLevel = 0;
+   static currentParent = [];
+   static space = ''
+   static results = {}
+   static testTitle = ''
+   static showFullError = false
+   static colors = {
+      bold:'\x1b[1m',
+      cblue:'\x1b[34m',
+      cred:'\x1b[31m',
+      cgreen:'\x1b[32m',
+      cgray:'\x1b[37m',
+      reset:'\x1b[0m'
+   }
+   static delay = (ms,toResolve) => new Promise((resolve) => {
+      setTimeout(() => {resolve(toResolve)}, ms);
+   });
+   static describe(title, callback,pause=false) {
+      if(pause) return
+      let { nestingLevel, currentParent } = SimpleTest
+      nestingLevel++;
+      currentParent.push(title);
+      callback();
+      currentParent.pop();
+      nestingLevel--;
+      if (nestingLevel === 0) {
+         SimpleTest.beforeEachCallback = null; // Clear beforeEachCallback after finishing the outermost describe block
+         SimpleTest.afterEachCallback = null; // Clear beforeEachCallback after finishing the outermost describe block
+      }
+   }
+   static beforeEach(callback) {SimpleTest.beforeEachCallback = callback;}
+   static afterEach(callback) {SimpleTest.afterEachCallback = callback;}
+   static beforeAll(callback) {SimpleTest.beforAllCallback = callback;}
+   static afterAll(callback) {SimpleTest.afterAllCallback = callback;}
+   static it(title, callback) {
+      SimpleTest.tests.push({
+         titles: [...SimpleTest.currentParent, title],
+         before: SimpleTest.beforeEachCallback,
+         after:SimpleTest.afterEachCallback,
+         test: callback,
+      });
+   }
+   static async runTests(consoleLog=true) {
+      const {bold,cblue,cred,reset} = SimpleTest.colors
+      SimpleTest.consoleLog = consoleLog
+      let { tests,results,showFullError,beforAllCallback,afterAllCallback } = SimpleTest;
+      let previousTitles = [];
+      if(typeof beforAllCallback == 'function') await beforAllCallback()
+      for(const test of tests) {
+         let curentResult = results
+         SimpleTest.space = test.titles.map(t => '  ').join('');
+         test.titles.forEach((title, index) => {
+            if(curentResult[title] == undefined) {
+               if(index == test.titles.length-1) curentResult[title] = []
+               else curentResult[title] = {}
+            }
+            curentResult = curentResult[title]
+            if(previousTitles[index] !== title) {
+               const indentation = '  '.repeat(index);
+               console.log(bold+cblue+'%s'+reset,`${indentation} ${title}`);
+               previousTitles[index] = title;
+            }
+         });
+         SimpleTest.curentResult = curentResult
+         try {
+            if (test.before) await test.before();
+            await test.test();
+            if (test.after) await test.after();
+         } catch (error) {
+            if(showFullError) console.log(error)
+            else console.log(`${SimpleTest.space}${cred}Error:${reset} ${error.message}`);
+            curentResult.push({error})
+         }
+         console.log('\n');
+      }
+      if(typeof afterAllCallback == 'function') await afterAllCallback()
+   }
+   static assert(value,testTitle) {
+      if(testTitle) SimpleTest.testTitle = testTitle
+      SimpleTest.logResult(value)
+   }
+   static expect(value1) {
+      let { logResult, isEqual } = SimpleTest
+      const methods = {
+         is: (text='') => {
+            SimpleTest.testTitle = text;
+            SimpleTest.not = false
+            return methods;
+         },
+         isNot: (text='') => {
+            SimpleTest.testTitle = text;
+            SimpleTest.not = true
+            return methods;
+         },
+         equalTo: (value2) => {logResult(value1 === value2);},
+         between(value2,value3) {logResult(value1 >= value2 && value1 <= value3);},
+         below(value2) {logResult(value1 < value2);},
+         above(value2) {logResult(value1 > value2);},
+         atLeast(value2) {logResult(value1 >= value2);},
+         atMost(value2) {logResult(value1 <= value2);},
+         sameAs: (value2) => {logResult(isEqual(value1, value2));},
+         defined: () => {logResult(value1 !== undefined);},
+         matchTo(pattern) {logResult(pattern.test(new RegExp(value1)));},
+         includes(value2) {logResult(value1.includes(value2));},
+         error: () => {
+            if(typeof value1 !== 'function') return console.log('Expected value has to be function')
+            try {
+               let result = value1()
+               if(result instanceof Error) logResult(true)
+               else logResult(false);
+            } catch (error) {logResult(true)}
+         },
+         hasProperty: (property) => {logResult(Object.prototype.hasOwnProperty.call(value1, property));},
+         instanceof: (classType) => {logResult(value1.constructor.name == classType.name)},
+         closeTo(value2, decimalPlaces = 2) {
+            const multiplier = 10 ** decimalPlaces;
+            const roundedActual = Math.round(value1 * multiplier);
+            const roundedExpected = Math.round(value2 * multiplier);
+            const diff = Math.abs(roundedActual - roundedExpected) / multiplier;
+            logResult(diff < 1 / multiplier);
+         }
+      };
+      return methods;
+   }
+   static logResult(result) {
+      let {curentResult,testTitle,not,space,colors} = SimpleTest
+      let {cgreen,cred,cgray,reset} = colors
+      if(not) result = !result
+      curentResult.push({result:result ? true : false,testTitle,error:null})
+      const status = result ? 'Success' : 'Failed';
+      const color = result ? cgreen : cred;
+      if (testTitle == '') console.log(`${color}${space}${status}${reset}`);
+      else console.log(`${space}${color}${status}: ${testTitle ? `${cgray}${testTitle}` : ''}`+reset,);
+      SimpleTest.not = false
+      SimpleTest.testTitle = ''
+   }
+   static isEqual(obj1, obj2, visited = new WeakMap()) {
+      if (obj1 === obj2) return true;
+      if (visited.has(obj1) && visited.get(obj1) === obj2) return true;
+      const type1 = typeof obj1;
+      const type2 = typeof obj2;
+      if (type1 !== type2 || type1 !== 'object' || obj1 === null || obj2 === null) return false;
+      visited.set(obj1, obj2);
+      const keys1 = Object.keys(obj1);
+      const keys2 = Object.keys(obj2);
+      if(keys1.length !== keys2.length) return false;
+      for (let key of keys1) {
+         if (!keys2.includes(key) || !SimpleTest.isEqual(obj1[key], obj2[key], visited)) return false;
+      }
+      return true;
+   };
+}
+try {module.exports = SimpleTest} catch (error) {}