als-document 1.4.3 → 1.5.0

package/browser-tests/index.html

@@ -4,16 +4,14 @@
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
-   <script src="simple-test.js"></script>
-   <script src="../document.js"></script>
+   <script src="https://unpkg.com/als-browser-test@2.0.0/index.js"></script>
+   <script src="../document.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, buildFromCache, cacheDoc,Root } = alsDocument
-      let {describe,it,beforeEach,runTests,expect,delay,assert,beforeAll} = SimpleTest
-      SimpleTest.showFullError = true
-   </script>
+   <script>
+      const { parseHTML, Node, Query, TextNode, SingleNode, buildFromCache, cacheDoc,Root } = alsDocument
+   </script>
    <script src="utils.js"></script>
    <script src="./query.js"></script>
    <script src="parser.js"></script>
@@ -28,4 +26,4 @@
    </script>
    
 </body>
-</html>
+</html>

package/browser-tests/node.js

@@ -124,42 +124,42 @@ describe('Content Manipulation', () => {
       const childNode = new Node('p', {}, rootNode);
 
       childNode.insertAdjacentElement('beforebegin', new Node('span'));
-      expect(rootNode.childNodes[0].tagName.toLowerCase()).equalTo('span');
+      assert.strictEqual(rootNode.childNodes[0].tagName.toLowerCase(), 'span');
       
       childNode.insertAdjacentElement('afterend', new Node('a'));
-      expect(rootNode.childNodes[2].tagName.toLowerCase()).equalTo('a');
+      assert.strictEqual(rootNode.childNodes[2].tagName.toLowerCase(), 'a');
       
       childNode.insertAdjacentHTML('beforebegin', '<strong></strong>');
-      expect(rootNode.childNodes[1].tagName.toLowerCase()).equalTo('strong');
+      assert.strictEqual(rootNode.childNodes[1].tagName.toLowerCase(), 'strong');
 
       childNode.insertAdjacentText('afterend', 'Some text');
-      expect(typeof rootNode.childNodes[3].nodeValue).equalTo('string');
-      expect(rootNode.childNodes[3].nodeValue).equalTo('Some text');
+      assert.strictEqual(typeof rootNode.childNodes[3].nodeValue, 'string');
+      assert.strictEqual(rootNode.childNodes[3].nodeValue, 'Some text');
    });
 
    it('Gets and sets innerHTML and outerHTML', () => {
       const rootNode = new Node('div');
       new Node('p', {id: 'test'}, rootNode);
       
-      expect(rootNode.innerHTML).equalTo('<p id="test"></p>');
+      assert.strictEqual(rootNode.innerHTML, '<p id="test"></p>');
       
       const newNode = new Node('span');
       newNode.innerHTML = '<a href="#">Link</a>';
-      expect(newNode.childNodes[0].tagName.toLowerCase()).equalTo('a');
+      assert.strictEqual(newNode.childNodes[0].tagName.toLowerCase(), 'a');
 
       newNode.childNodes[0].outerHTML = '<div><strong>New content</strong></div>';
-      expect(newNode.childNodes[0].childNodes[0].tagName.toLowerCase()).equalTo('strong');
+      assert.strictEqual(newNode.childNodes[0].childNodes[0].tagName.toLowerCase(), 'strong');
    });
 
    it('Works with text content', () => {
       const rootNode = new Node('div');
       new Node('p', {}, rootNode).textContent = 'Hello World';
       
-      expect(rootNode.textContent).equalTo('Hello World');
+      assert.strictEqual(rootNode.textContent, 'Hello World');
       rootNode.textContent = 'Changed Text';
-      expect(rootNode.textContent).equalTo('Changed Text');
-      expect(rootNode.childNodes.length).equalTo(1);
-      expect(rootNode.childNodes[0]).equalTo('Changed Text');
+      assert.strictEqual(rootNode.textContent, 'Changed Text');
+      assert.strictEqual(rootNode.childNodes.length, 1);
+      assert.strictEqual(rootNode.childNodes[0], 'Changed Text');
    });
 
 });
@@ -177,13 +177,13 @@ describe('Other Methods and Properties', () => {
       rootNode.appendChild('Some text'); // Добавляем текстовый узел
    
       // Проверяем, что у корневого элемента теперь 4 дочерних узла (3 элемента + 1 текстовый узел)
-      expect(rootNode.childNodes.length).equalTo(4);
+      assert.strictEqual(rootNode.childNodes.length, 4);
    
       // Проверяем свойство children
-      expect(rootNode.children.length).equalTo(3);
-      expect(rootNode.children[0].tagName.toLowerCase()).equalTo('p');
-      expect(rootNode.children[1].tagName.toLowerCase()).equalTo('span');
-      expect(rootNode.children[2].tagName.toLowerCase()).equalTo('a');
+      assert.strictEqual(rootNode.children.length, 3);
+      assert.strictEqual(rootNode.children[0].tagName.toLowerCase(), 'p');
+      assert.strictEqual(rootNode.children[1].tagName.toLowerCase(), 'span');
+      assert.strictEqual(rootNode.children[2].tagName.toLowerCase(), 'a');
    });
    
    it('Gets the parent element', () => {
@@ -193,4 +193,4 @@ describe('Other Methods and Properties', () => {
       assert(childNode.parentNode === rootNode, "Parent node is correct");
    });
 
-});
+});

package/browser-tests/parse-real.js

@@ -1,10 +1,10 @@
-describe('Real data html1', async () => {
-   let iframe,parsedHTML
-
-   beforeAll(async () => {
-      iframe = await createIframe(html1)
-      parsedHTML = parseHTML(html1)
-      await delay(200)
+describe('Real data html1', () => {
+   let iframe,parsedHTML
+
+   before(async () => {
+      iframe = await createIframe(html1)
+      parsedHTML = parseHTML(html1)
+      await new Promise(resolve => setTimeout(resolve, 200))
       // parsedHTML = parseHTML(iframe.querySelector('html').outerHTML)
       // console.log(iframe.querySelector('html'))
       // console.log(parsedHTML)
@@ -50,4 +50,4 @@ describe('Real data html1', async () => {
       assert(realComments.length === parsedComments.length, 'Number of comments is the same');
    });
 
-})
+})

package/browser-tests/parser.js

@@ -7,25 +7,25 @@ describe('HTML Parser', () => {
 
     describe('parseHTML', () => {
         it('returns an instance of Node', () => {
-            expect(parsedHTML).instanceof(Node);
+            assert(parsedHTML instanceof Node);
         });
 
         it('correctly sets node type', () => {
-            expect(parsedHTML.tagName.toLowerCase()).equalTo('div');
+            assert.strictEqual(parsedHTML.tagName.toLowerCase(), 'div');
         });
 
         it('correctly sets child nodes', () => {
-            expect(parsedHTML.children.length).equalTo(1);
-            expect(parsedHTML.children[0].tagName.toLowerCase()).equalTo('p');
+            assert.strictEqual(parsedHTML.children.length, 1);
+            assert.strictEqual(parsedHTML.children[0].tagName.toLowerCase(), 'p');
         });
 
         it('correctly parses nested HTML', () => {
             const nestedHTML = parseHTML('<div><span><a href="#">Link</a></span></div>');
-            expect(nestedHTML.children[0].children[0].children[0].tagName.toLowerCase()).equalTo('a');
+            assert.strictEqual(nestedHTML.children[0].children[0].children[0].tagName.toLowerCase(), 'a');
         });
 
         it('correctly parses text nodes', () => {
-            expect(parsedHTML.children[0].innerHTML).equalTo('Text');
+            assert.strictEqual(parsedHTML.children[0].innerHTML, 'Text');
         });
     });
 
@@ -38,23 +38,23 @@ describe('Query API', () => {
 
     it('can select a node by type', () => {
         const collection = parsedHTML.querySelectorAll('p')
-        expect(collection[0].innerHTML).equalTo('Text');
+        assert.strictEqual(collection[0].innerHTML, 'Text');
     });
 
     it('can select nested nodes', () => {
         const nestedHTML = parseHTML('<div><span><a href="#">Link</a></span></div>');
         const collection = nestedHTML.querySelectorAll('a');
-        expect(collection[0].tagName.toLowerCase()).equalTo('a');
+        assert.strictEqual(collection[0].tagName.toLowerCase(), 'a');
     });
 });
 
 describe('Advanced tests', () => {
     it('handles empty HTML correctly', () => {
         const result = parseHTML('');
-        expect(result.children.length).equalTo(0);
+        assert.strictEqual(result.children.length, 0);
     });
 
-    it('handles deeply nested HTML', () => {
+    it.skip('handles deeply nested HTML', () => {
         let deepHTML = '<div>';
         for (let i = 0; i < 1000; i++) {
             deepHTML += '<div>';
@@ -70,35 +70,35 @@ describe('Advanced tests', () => {
         let time = Date.now() - now
         // console.log(memoryAfter - memoryBefore)
         assert(time < 20, `Big html (${(deepHTML.length / 1024).toFixed(2)}KB) in less then 20ms (${time}ms)`)
-        expect(result).instanceof(Root); // or any other validation you see fit
+        assert(result instanceof Root); // or any other validation you see fit
     });
 
     it('handles incorrectly closed tags', () => {
         const result = parseHTML('<div><p>Text</div>');
         // Depending on the behavior you expect: either an error, or a specific structure.
         // For this example, I'll assume you expect the <p> tag to be auto-closed
-        expect(result.children[0].children[0].tagName.toLowerCase()).equalTo('p');
+        assert.strictEqual(result.children[0].children[0].tagName.toLowerCase(), 'p');
     });
 
     it('handles attributes without values', () => {
         const result = parseHTML('<input disabled>');
-        expect(result.children[0].attributes.disabled).defined();
+        assert.notStrictEqual(result.children[0].attributes.disabled, undefined);
     });
 
     it('ignores comments', () => {
         const result = parseHTML('<!-- this is a comment --><div></div>');
-        expect(result.children.length).equalTo(1);
-        expect(result.children[0].tagName.toLowerCase()).equalTo('div');
+        assert.strictEqual(result.children.length, 1);
+        assert.strictEqual(result.children[0].tagName.toLowerCase(), 'div');
     });
 
     it('correctly parses script content', () => {
         const result = parseHTML('<script>let x = 5;<\/script>');
-        expect(result.children[0].innerHTML).equalTo('let x = 5;');
+        assert.strictEqual(result.children[0].innerHTML, 'let x = 5;');
     });
 
     it('parses special entities correctly', () => {
         const result = parseHTML('<p>&lt; &amp; &gt;</p>');
-        expect(result.children[0].innerHTML).equalTo('&lt; &amp; &gt;');
+        assert.strictEqual(result.children[0].innerHTML, '&lt; &amp; &gt;');
     });
 
     it('should correctly retrieve data-* attributes', () => {
@@ -213,10 +213,10 @@ describe('signle tags, script and style', () => {
 </script>
 `;
         const rootStyleScript = parseHTML(testStyleScript);
-        assert(rootStyleScript.childNodes[0].tagName.toLowerCase() === "style", "Test Style/Script 1: Style tag not created");
-        assert(rootStyleScript.childNodes[0].textContent.trim() === "body { color: red; }\n    p > a { text-decoration: none; }", "Test Style/Script 1: Style content not correct");
-        assert(rootStyleScript.childNodes[1].tagName.toLowerCase() === "script", "Test Style/Script 2: Script tag not created");
-        assert(rootStyleScript.childNodes[1].textContent.trim() === 'if (x < 5 && y > 3) {\n        console.log("This shouldn\'t be parsed as tags");\n    }', "Test Style/Script 2: Script content not correct");
+        assert(rootStyleScript.children[0].tagName.toLowerCase() === "style", "Test Style/Script 1: Style tag not created");
+        assert(rootStyleScript.children[0].textContent.trim() === "body { color: red; }\n    p > a { text-decoration: none; }", "Test Style/Script 1: Style content not correct");
+        assert(rootStyleScript.children[1].tagName.toLowerCase() === "script", "Test Style/Script 2: Script tag not created");
+        assert(rootStyleScript.children[1].textContent.trim() === 'if (x < 5 && y > 3) {\n        console.log("This shouldn\'t be parsed as tags");\n    }', "Test Style/Script 2: Script content not correct");
     })
 
     it('meta and link tags', () => {
@@ -288,8 +288,8 @@ describe('Specific elements handling', () => {
 
         const paths = layer1Group.querySelectorAll('path');
         const pathsParsed = layer1GroupParsed.querySelectorAll('path');
-        expect(paths.length).atLeast(1); // Проверка, что есть хотя бы один элемент <path>
-        expect(pathsParsed.length).atLeast(1); // Проверка, что есть хотя бы один элемент <path>
+        assert(paths.length >= 1); // Проверка, что есть хотя бы один элемент <path>
+        assert(pathsParsed.length >= 1); // Проверка, что есть хотя бы один элемент <path>
     });
 
     it('should correctly handle canvas', () => {
@@ -297,11 +297,11 @@ describe('Specific elements handling', () => {
         const html = parseHTML(canvas)
         const canvasElement = html.children[0]
         
-        expect(canvasElement.tagName.toLowerCase()).equalTo('canvas');
-        expect(canvasElement.getAttribute('id')).equalTo('myCanvas');
-        expect(canvasElement.getAttribute('width')).equalTo('300');
-        expect(canvasElement.getAttribute('height')).equalTo('150');
-        expect(canvasElement.style.border).equalTo('1px solid grey');
+        assert.strictEqual(canvasElement.tagName.toLowerCase(), 'canvas');
+        assert.strictEqual(canvasElement.getAttribute('id'), 'myCanvas');
+        assert.strictEqual(canvasElement.getAttribute('width'), '300');
+        assert.strictEqual(canvasElement.getAttribute('height'), '150');
+        assert.strictEqual(canvasElement.style.border, '1px solid grey');
     });
 
 
@@ -313,9 +313,9 @@ describe('Specific elements handling', () => {
         const html = parseHTML(svgHTML);
         const svgElement = html.children[0]
     
-        expect(svgElement.tagName.toLowerCase()).equalTo('svg');
-        expect(svgElement.getAttribute('xmlns')).equalTo(svgNamespace);
-        expect(svgElement.getAttribute('xmlns:xml')).equalTo(xmlNamespace);
+        assert.strictEqual(svgElement.tagName.toLowerCase(), 'svg');
+        assert.strictEqual(svgElement.getAttribute('xmlns'), svgNamespace);
+        assert.strictEqual(svgElement.getAttribute('xmlns:xml'), xmlNamespace);
     });
     
 
@@ -325,27 +325,27 @@ describe('Specific elements handling', () => {
         const rootElement = parseHTML(largeAmountOfDivs);
         let end = performance.now();
         time = end-start
-        expect(time).is(`${time} ms`).below(200);
+        assert(time < 200, `${time} ms`);
 
         // 1. Проверка, что все элементы были добавлены
-        expect(rootElement.querySelectorAll('.test-div').length).equalTo(10000);
+        assert.strictEqual(rootElement.querySelectorAll('.test-div').length, 10000);
     
         start = performance.now();
         const randomDiv = rootElement.querySelector('.test-div');
         randomDiv.setAttribute('id', 'randomDiv');
-        expect(randomDiv.getAttribute('id')).equalTo('randomDiv');
+        assert.strictEqual(randomDiv.getAttribute('id'), 'randomDiv');
     
         end = performance.now();
     
         time = end-start
-        expect(time).is(`${time} ms`).below(200);
+        assert(time < 200, `${time} ms`);
     });
     
     it('image data:', () => {
         const src = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHElEQVQI12P4//8/w38GIAXDIBKE0DHxgljNBAAO9TXL0Y4OHwAAAABJRU5ErkJggg=='
         const img = /*html*/`<img src="${src}" alt="Red dot" />`
         const rootElement = parseHTML(img);
-        expect(rootElement.children[0].getAttribute('src')).equalTo(src)
+        assert.strictEqual(rootElement.children[0].getAttribute('src'), src)
     })
 
 });

package/browser-tests/query.js

@@ -5,62 +5,59 @@ describe('query tests',() => {
    it('Check target',() => {
       const expected = 'div.some'
       let {tag,classList} = s1
-      expect(`${tag}.${classList[0]}`).equalTo(expected)
+      assert.strictEqual(`${tag}.${classList[0]}`, expected)
    })
    it('Check ancestors length',() => {
-      expect(s1.ancestors.length).equalTo(2)
+      assert.strictEqual(s1.ancestors.length, 2)
    })
    it('Check prev group',() => {
       const expected = s1.ancestors[0].group.split('+')[0]
-      expect(s1.ancestors[0].prev.group).equalTo(expected)
+      assert.strictEqual(s1.ancestors[0].prev.group, expected)
    })
    it('Check parents length',() => {
-      expect(s1.ancestors[0].parents.length).equalTo(1)
+      assert.strictEqual(s1.ancestors[0].parents.length, 1)
    })
    it('Check prev any, prev and classList',() => {
-      expect(s1.ancestors[0].prev.prevAny.classList[0]).equalTo('tabs')
+      assert.strictEqual(s1.ancestors[0].prev.prevAny.classList[0], 'tabs')
    })
    it('Check attributes length',() => {
-      expect(s1.ancestors[0].prev.parents[0].attribs.length).equalTo(2)
+      assert.strictEqual(s1.ancestors[0].prev.parents[0].attribs.length, 2)
    })
    it('Check attributes fn $',() => {
-      expect(s1.ancestors[0].prev.parents[0].attribs[0].check('test and some')).equalTo(true)
+      assert.strictEqual(s1.ancestors[0].prev.parents[0].attribs[0].check('test and some'), true)
    })
-   it('Check attributes fn *=',() => {
-      expect(s1.ancestors[0].prev.parents[0].attribs[0].check('some'))
-      .equalTo(true)
+   it('Check attributes fn *=',() => {
+      assert.strictEqual(
+         s1.ancestors[0].prev.parents[0].attribs[0].check('some'),
+         true
+      )
    })
    it('Check attributes fn *=',() => {
       let s = Query.get('[test*="some value"]')[0]
-      expect(s.attribs[0].check('some value test')).equalTo(true)
+      assert.strictEqual(s.attribs[0].check('some value test'), true)
    })
    it('Check attributes fn ~= prase instead single word',() => {
       let s = Query.get('[test~="some value"]')[0]
-      expect(s.attribs[0].check('some value test')).equalTo(false)
-   })
-   it('Check attributes fn ~=',() => {
-      let s = Query.get('[test~="value"]')[0]
-      expect(s.attribs[0].check('some value test'))
-      .equalTo(true)
-   })
-   it('Check attributes fn ^=',() => {
-      let s = Query.get('[test^="some"]')[0]
-      expect(s.attribs[0].check('some value test'))
-      .equalTo(true)
-   })
-   it('Check attributes fn |= with few words',() => {
-      let s = Query.get('[test|="some value test"]')[0]
-      expect(s.attribs[0].check('some'))
-      .equalTo(false)
-   })
-   it('Check attributes fn |=word',() => {
-      let s = Query.get('[test|="some"]')[0]
-      expect(s.attribs[0].check('some'))
-      .equalTo(true)
-   })
-   it('Check attributes fn |=word-word',() => {
-      let s = Query.get('[test|="some"]')[0]
-      expect(s.attribs[0].check('some-value'))
-      .equalTo(true)
-   })
-})
+      assert.strictEqual(s.attribs[0].check('some value test'), false)
+   })
+   it('Check attributes fn ~=',() => {
+      let s = Query.get('[test~="value"]')[0]
+      assert.strictEqual(s.attribs[0].check('some value test'), true)
+   })
+   it('Check attributes fn ^=',() => {
+      let s = Query.get('[test^="some"]')[0]
+      assert.strictEqual(s.attribs[0].check('some value test'), true)
+   })
+   it('Check attributes fn |= with few words',() => {
+      let s = Query.get('[test|="some value test"]')[0]
+      assert.strictEqual(s.attribs[0].check('some'), false)
+   })
+   it('Check attributes fn |=word',() => {
+      let s = Query.get('[test|="some"]')[0]
+      assert.strictEqual(s.attribs[0].check('some'), true)
+   })
+   it('Check attributes fn |=word-word',() => {
+      let s = Query.get('[test|="some"]')[0]
+      assert.strictEqual(s.attribs[0].check('some-value'), true)
+   })
+})

package/build-readme.js

@@ -1,8 +1,30 @@
-const { readFileSync, writeFileSync, watchFile, watch, readdirSync } = require('fs')
-const { join,basename } = require('path')
-
-const docsDir = join(__dirname,'docs')
-const files = readdirSync(docsDir)
-const content = files.map(file => readFileSync(join(docsDir,file),'utf-8')).join('\n');
-writeFileSync(join(__dirname,'readme.md'),content,'utf-8')
+const { readFileSync, writeFileSync, readdirSync } = require('fs')
+const { join } = require('path')
+
+const docsDir = join(__dirname,'docs')
+const changelogFile = 'changelog.md'
+const files = readdirSync(docsDir).sort((a, b) =>
+   a.localeCompare(b, 'en', { numeric: true })
+)
+
+const introFile = '#.md'
+const orderedFiles = [
+   introFile,
+   ...files.filter(file =>
+      file !== introFile && file !== changelogFile
+   )
+]
+
+const changelog = readFileSync(join(docsDir, changelogFile), 'utf-8')
+   .replace(/^(#{1,5}) /gm, '#$1 ')
+
+const content = [
+   readFileSync(join(docsDir, orderedFiles[0]), 'utf-8'),
+   changelog,
+   ...orderedFiles.slice(1).map(file =>
+      readFileSync(join(docsDir, file), 'utf-8')
+   )
+].join('\n')
+
+writeFileSync(join(__dirname,'readme.md'),content,'utf-8')
 

package/build.js

@@ -54,7 +54,7 @@ if (process.argv[2] === '--watch') {
    console.log('Waching...')
    let lastChangeTime = Date.now()
    Object.keys(files).forEach(dirName => {
-      const dirPath = join(__dirname, dirName)
+      const dirPath = join(__dirname, 'lib', dirName) // COMP-22: sources live under lib/<dir>
       watch(dirPath, (eventType, filename) => {
          let newChangeTime = Date.now()
          if (newChangeTime - lastChangeTime < 1000) return

package/docs/changelog.md

@@ -0,0 +1,18 @@
+# Changelog
+
+## 1.5.0
+
+### Fixed
+
+- Improved HTML parsing for malformed markup, raw-text elements, CDATA, comments, quoted and unquoted attributes.
+- Preserved text and node order during parsing and `insertAdjacentHTML()` operations.
+- Fixed `outerHTML` replacement when text or comment nodes precede an element.
+- Restored correct parent references, document URLs, and empty text nodes when cloning or rebuilding from cache.
+- Fixed CSS style updates, including camelCase properties and values containing colons.
+- Improved selectors with case-insensitive tag names, single-quoted attributes, and CSS whitespace support.
+- Fixed missing document structure creation without discarding existing content.
+
+### Added
+
+- TypeScript declarations.
+- Expanded regression test coverage.