@asamuzakjp/dom-selector 2.0.2-a.1 → 2.0.2-a.3

package/package.json

@@ -59,5 +59,5 @@
     "tsc": "npx tsc",
     "update-wpt": "git submodule update --init --recursive --remote"
   },
-  "version": "2.0.2-a.1"
+  "version": "2.0.2-a.3"
 }

package/src/index.js

@@ -8,8 +8,11 @@
 /* import */
 import { Matcher } from './js/matcher.js';
 
-/* instance */
-let matcher = new Matcher();
+/* export for test */
+export { Matcher };
+
+/* instance, export for test */
+export let matcher = new Matcher();
 
 /**
  * matches
@@ -27,7 +30,9 @@ export const matches = (selector, node, opt) => {
     }
     res = matcher.matches(node, selector, opt);
   } catch (e) {
-    matcher = null;
+    if (e instanceof Error) {
+      matcher = null;
+    }
     throw e;
   }
   return res;
@@ -49,7 +54,9 @@ export const closest = (selector, node, opt) => {
     }
     res = matcher.closest(node, selector, opt);
   } catch (e) {
-    matcher = null;
+    if (e instanceof globalThis[e.name]) {
+      matcher = null;
+    }
     throw e;
   }
   return res;
@@ -71,7 +78,9 @@ export const querySelector = (selector, node, opt) => {
     }
     res = matcher.querySelector(node, selector, opt);
   } catch (e) {
-    matcher = null;
+    if (e instanceof globalThis[e.name]) {
+      matcher = null;
+    }
     throw e;
   }
   return res;
@@ -94,7 +103,9 @@ export const querySelectorAll = (selector, node, opt) => {
     }
     res = matcher.querySelectorAll(node, selector, opt);
   } catch (e) {
-    matcher = null;
+    if (e instanceof globalThis[e.name]) {
+      matcher = null;
+    }
     throw e;
   }
   return res;

package/src/js/matcher.js

@@ -107,7 +107,7 @@ export class Matcher {
       } else if (this.#window) {
         throw new this.#window.DOMException(e.message, e.name);
       } else {
-        throw new DOMException(e.message, e.name);
+        throw e;
       }
     } else {
       throw e;
@@ -115,9 +115,9 @@ export class Matcher {
   }
 
   /**
-   * set up #window, #document, #root, #walker
+   * set up #window, #document, #root
    * @param {object} node - Document, DocumentFragment, Element node
-   * @returns {Array.<object>} - array of #window, #document, #root, #walker
+   * @returns {Array.<object>} - array of #window, #document, #root
    */
   _setup(node) {
     let document;
@@ -146,7 +146,11 @@ export class Matcher {
               break;
             }
           }
-          document = parent.ownerDocument;
+          if (parent.nodeType === DOCUMENT_NODE) {
+            document = parent;
+          } else {
+            document = parent.ownerDocument;
+          }
           root = parent;
         }
         break;
@@ -163,13 +167,11 @@ export class Matcher {
         throw new TypeError(msg);
       }
     }
-    const walker = document.createTreeWalker(root, WALKER_FILTER);
     const window = document.defaultView;
     return [
       window,
       document,
-      root,
-      walker
+      root
     ];
   }
 
@@ -206,56 +208,95 @@ export class Matcher {
    * @returns {Array.<Array.<object|undefined>>} - array of #ast and #nodes
    */
   _correspond(selector) {
-    let cssAst;
-    try {
-      cssAst = parseSelector(selector);
-    } catch (e) {
-      this._onError(e);
-    }
-    const branches = walkAST(cssAst);
-    const ast = [];
     const nodes = [];
-    let i = 0;
-    for (const [...items] of branches) {
-      const branch = [];
-      let item = items.shift();
-      if (item && item.type !== COMBINATOR) {
-        const leaves = new Set();
-        while (item) {
-          if (item.type === COMBINATOR) {
-            const [nextItem] = items;
-            if (nextItem.type === COMBINATOR) {
-              const msg = `Invalid combinator ${item.name}${nextItem.name}`;
-              throw new this.#window.DOMException(msg, SYNTAX_ERR);
-            }
-            branch.push({
-              combo: item,
-              leaves: this._sortLeaves(leaves)
-            });
-            leaves.clear();
-          } else if (item) {
-            leaves.add(item);
+    let ast;
+    let cachedItem = this.#document && this.#cache.get(this.#document);
+    if (cachedItem && cachedItem.has(`${selector}`)) {
+      ast = cachedItem.get(selector);
+      if (typeof ast === 'string') {
+        throw new DOMException(ast, SYNTAX_ERR);
+      }
+    }
+    if (ast) {
+      const l = ast.length;
+      for (let i = 0; i < l; i++) {
+        ast[i].dir = null;
+        ast[i].filtered = false;
+        ast[i].find = false;
+        nodes[i] = new Set();
+      }
+    } else {
+      let cssAst;
+      try {
+        cssAst = parseSelector(selector);
+      } catch (e) {
+        if (this.#document) {
+          if (!cachedItem) {
+            cachedItem = new Map();
           }
-          if (items.length) {
-            item = items.shift();
-          } else {
-            branch.push({
-              combo: null,
-              leaves: this._sortLeaves(leaves)
-            });
-            leaves.clear();
-            break;
+          cachedItem.set(`${selector}`, e.message);
+          this.#cache.set(this.#document, cachedItem);
+        }
+        this._onError(e);
+      }
+      const branches = walkAST(cssAst);
+      ast = [];
+      let i = 0;
+      for (const [...items] of branches) {
+        const branch = [];
+        let item = items.shift();
+        if (item && item.type !== COMBINATOR) {
+          const leaves = new Set();
+          while (item) {
+            if (item.type === COMBINATOR) {
+              const [nextItem] = items;
+              if (nextItem.type === COMBINATOR) {
+                const msg = `Invalid selector ${selector}`;
+                if (this.#document) {
+                  if (!cachedItem) {
+                    cachedItem = new Map();
+                  }
+                  cachedItem.set(`${selector}`, msg);
+                  this.#cache.set(this.#document, cachedItem);
+                }
+                throw new DOMException(msg, SYNTAX_ERR);
+              }
+              branch.push({
+                combo: item,
+                leaves: this._sortLeaves(leaves)
+              });
+              leaves.clear();
+            } else if (item) {
+              leaves.add(item);
+            }
+            if (items.length) {
+              item = items.shift();
+            } else {
+              branch.push({
+                combo: null,
+                leaves: this._sortLeaves(leaves)
+              });
+              leaves.clear();
+              break;
+            }
           }
         }
+        ast.push({
+          branch,
+          dir: null,
+          filtered: false,
+          find: false
+        });
+        nodes[i] = new Set();
+        i++;
+      }
+      if (this.#document) {
+        if (!cachedItem) {
+          cachedItem = new Map();
+        }
+        cachedItem.set(`${selector}`, ast);
+        this.#cache.set(this.#document, cachedItem);
       }
-      ast.push({
-        branch,
-        dir: null,
-        filtered: false,
-        find: false
-      });
-      nodes[i] = new Set();
-      i++;
     }
     return [
       ast,
@@ -2291,26 +2332,22 @@ export class Matcher {
   }
 
   /**
-   * find matched node from tree walker
+   * find matched node from finder
    * @param {Array.<object>} leaves - AST leaves
    * @param {object} [opt] - options
    * @param {object} [opt.node] - node to start from
-   * @param {object} [opt.tree] - tree walker
    * @returns {?object} - matched node
    */
   _findNode(leaves, opt = {}) {
-    let { node, walker } = opt;
-    if (!walker) {
-      walker = this.#tree;
-    }
+    const { node } = opt;
     let matchedNode;
-    let refNode = this._traverse(node, walker);
+    let refNode = this._traverse(node, this.#finder);
     if (refNode) {
       if (refNode.nodeType !== ELEMENT_NODE) {
-        refNode = walker.nextNode();
+        refNode = this.#finder.nextNode();
       } else if (refNode === node) {
         if (refNode !== this.#root) {
-          refNode = walker.nextNode();
+          refNode = this.#finder.nextNode();
         }
       }
       while (refNode) {
@@ -2331,7 +2368,7 @@ export class Matcher {
             break;
           }
         }
-        refNode = walker.nextNode();
+        refNode = this.#finder.nextNode();
       }
     }
     return matchedNode ?? null;
@@ -2370,15 +2407,14 @@ export class Matcher {
             }
             refNode = refNode.parentNode;
           }
-        } else if (targetType === TARGET_ALL ||
-                   this.#root.nodeType === ELEMENT_NODE) {
-          pending = true;
-        } else {
+        } else if (targetType === TARGET_FIRST &&
+                   this.#root.nodeType !== ELEMENT_NODE) {
           const node = this.#root.getElementById(leafName);
           if (node) {
             nodes.add(node);
-            filtered = true;
           }
+        } else {
+          pending = true;
         }
         break;
       }
@@ -2402,17 +2438,13 @@ export class Matcher {
           }
         } else if (targetType === TARGET_FIRST) {
           const node = this._findNode(leaves, {
-            node: this.#node,
-            walker: this.#finder
+            node: this.#node
           });
           if (node) {
             nodes.add(node);
             filtered = true;
           }
-        } else if (this.#root.nodeType === DOCUMENT_FRAGMENT_NODE ||
-                   this.#root.nodeType === ELEMENT_NODE) {
-          pending = true;
-        } else {
+        } else if (this.#root.nodeType === DOCUMENT_NODE) {
           const arr =
             [].slice.call(this.#root.getElementsByClassName(leafName));
           if (this.#node.nodeType === ELEMENT_NODE) {
@@ -2424,6 +2456,8 @@ export class Matcher {
           } else if (arr.length) {
             nodes = new Set(arr);
           }
+        } else {
+          pending = true;
         }
         break;
       }
@@ -2452,19 +2486,15 @@ export class Matcher {
           }
         } else if (targetType === TARGET_FIRST) {
           const node = this._findNode(leaves, {
-            node: this.#node,
-            walker: this.#finder
+            node: this.#node
           });
           if (node) {
             nodes.add(node);
             filtered = true;
           }
-        } else if (this.#document.contentType !== 'text/html' ||
-                   /[*|]/.test(leafName) ||
-                   this.#root.nodeType === DOCUMENT_FRAGMENT_NODE ||
-                   this.#root.nodeType === ELEMENT_NODE) {
-          pending = true;
-        } else {
+        } else if (this.#document.contentType === 'text/html' &&
+                   this.#root.nodeType === DOCUMENT_NODE &&
+                   !/[*|]/.test(leafName)) {
           const arr = [].slice.call(this.#root.getElementsByTagName(leafName));
           if (this.#node.nodeType === ELEMENT_NODE) {
             for (const node of arr) {
@@ -2475,6 +2505,8 @@ export class Matcher {
           } else if (arr.length) {
             nodes = new Set(arr);
           }
+        } else {
+          pending = true;
         }
         break;
       }
@@ -2509,8 +2541,7 @@ export class Matcher {
           }
         } else if (targetType === TARGET_FIRST) {
           const node = this._findNode(leaves, {
-            node: this.#node,
-            walker: this.#finder
+            node: this.#node
           });
           if (node) {
             nodes.add(node);
@@ -2542,9 +2573,20 @@ export class Matcher {
     let dir;
     let twig;
     if (complex) {
-      const { combo: firstCombo, leaves: [{ type: firstType }] } = firstTwig;
+      const {
+        combo: firstCombo,
+        leaves: [{
+          name: firstName,
+          type: firstType
+        }]
+      } = firstTwig;
       const lastTwig = branch[branchLen - 1];
-      const { leaves: [{ type: lastType }] } = lastTwig;
+      const {
+        leaves: [{
+          name: lastName,
+          type: lastType
+        }]
+      } = lastTwig;
       if (lastType === SELECTOR_PSEUDO_ELEMENT || lastType === SELECTOR_ID) {
         dir = DIR_PREV;
         twig = lastTwig;
@@ -2553,7 +2595,13 @@ export class Matcher {
         dir = DIR_NEXT;
         twig = firstTwig;
       } else if (targetType === TARGET_ALL) {
-        if (branchLen === 2) {
+        if (firstName === '*' && firstType === SELECTOR_TYPE) {
+          dir = DIR_PREV;
+          twig = lastTwig;
+        } else if (lastName === '*' && lastType === SELECTOR_TYPE) {
+          dir = DIR_NEXT;
+          twig = firstTwig;
+        } else if (branchLen === 2) {
           const { name: comboName } = firstCombo;
           if (/^[+~]$/.test(comboName)) {
             dir = DIR_PREV;
@@ -2566,6 +2614,12 @@ export class Matcher {
           dir = DIR_NEXT;
           twig = firstTwig;
         }
+      } else if (lastName === '*' && lastType === SELECTOR_TYPE) {
+        dir = DIR_NEXT;
+        twig = firstTwig;
+      } else if (firstName === '*' && firstType === SELECTOR_TYPE) {
+        dir = DIR_PREV;
+        twig = lastTwig;
       } else {
         let bool;
         let sibling;
@@ -2790,10 +2844,10 @@ export class Matcher {
                       if (nodes.size) {
                         const n = [...nodes];
                         nodes = new Set([...n, ...arr]);
-                        this.#sort = true;
                       } else {
                         nodes = new Set([...arr]);
                       }
+                      this.#sort = true;
                     } else {
                       const [node] = this._sortNodes(arr);
                       nodes.add(node);
@@ -2819,8 +2873,7 @@ export class Matcher {
           if (!matched && targetType === TARGET_FIRST) {
             const [entryNode] = [...entryNodes];
             let refNode = this._findNode(entryLeaves, {
-              node: entryNode,
-              walker: this.#finder
+              node: entryNode
             });
             while (refNode) {
               let nextNodes = new Set([refNode]);
@@ -2856,8 +2909,7 @@ export class Matcher {
                 break;
               }
               refNode = this._findNode(entryLeaves, {
-                node: refNode,
-                walker: this.#finder
+                node: refNode
               });
               nextNodes = new Set([refNode]);
             }
@@ -2883,6 +2935,10 @@ export class Matcher {
                   if (j === 0) {
                     nodes.add(node);
                     matched = true;
+                    if (targetType === TARGET_ALL &&
+                        branchLen > 1 && nodes.size > 1) {
+                      this.#sort = true;
+                    }
                   } else {
                     nextNodes = new Set(arr);
                     matched = false;
@@ -2900,8 +2956,7 @@ export class Matcher {
           if (!matched && targetType === TARGET_FIRST) {
             const [entryNode] = [...entryNodes];
             let refNode = this._findNode(entryLeaves, {
-              node: entryNode,
-              walker: this.#finder
+              node: entryNode
             });
             while (refNode) {
               let nextNodes = new Set([refNode]);
@@ -2931,8 +2986,7 @@ export class Matcher {
                 break;
               }
               refNode = this._findNode(entryLeaves, {
-                node: refNode,
-                walker: this.#finder
+                node: refNode
               });
               nextNodes = new Set([refNode]);
             }
@@ -2969,20 +3023,13 @@ export class Matcher {
       const msg = `Unexpected node ${node.nodeName}`;
       throw new TypeError(msg);
     }
-    this.#cache = new WeakMap();
     this.#node = node;
-    [this.#window, this.#document, this.#root, this.#tree] = this._setup(node);
+    [this.#window, this.#document, this.#root] = this._setup(node);
     this.#shadow = isInShadowTree(node);
-    if (selector && selector === this.#selector) {
-      for (const i of this.#nodes) {
-        i.clear();
-      }
-    } else {
-      this.#selector = selector;
-      [this.#ast, this.#nodes] = this._correspond(selector);
-    }
-    // prepare #finder
+    this.#selector = selector;
+    [this.#ast, this.#nodes] = this._correspond(selector);
     if (targetType === TARGET_ALL || targetType === TARGET_FIRST) {
+      this.#tree = this.#document.createTreeWalker(this.#root, WALKER_FILTER);
       this.#finder = this.#document.createTreeWalker(this.#node, SHOW_ELEMENT);
       this.#sort = false;
     }

package/types/index.d.ts

@@ -1,3 +1,5 @@
+export { Matcher };
+export let matcher: Matcher;
 export function matches(selector: string, node: object, opt?: {
     warn?: boolean;
 }): boolean;
@@ -10,3 +12,4 @@ export function querySelector(selector: string, node: object, opt?: {
 export function querySelectorAll(selector: string, node: object, opt?: {
     warn?: boolean;
 }): Array<object | undefined>;
+import { Matcher } from './js/matcher.js';

package/types/js/matcher.d.ts

@@ -42,7 +42,6 @@ export class Matcher {
     }): Set<object>;
     _findNode(leaves: Array<object>, opt?: {
         node?: object;
-        tree?: object;
     }): object | null;
     _findEntryNodes(twig: object, targetType: string): object;
     _getEntryTwig(branch: Array<object>, targetType: string): object;