temp commit

src/match.ts

@@ -0,0 +1,78 @@
+import CSSwhat from "css-what";
+import { traverseGenerator } from "./traverse";
+import { FiberNode } from "./mocked-types";
+import { isNodeNotHtmlLike } from "./utils";
+
+function* matchGenerator(
+  node: FiberNode,
+  match: string | CSSwhat.Selector[][]
+): IterableIterator<FiberNode> {
+  // Either parse match string or allow parsed match object as it is
+  let matchParsed: CSSwhat.Selector[][];
+  if (typeof match === "string") {
+    matchParsed = CSSwhat.parse(match);
+  } else {
+    matchParsed = match;
+  }
+
+  // If selector is a combination of multiple basic selectors (a, b),
+  // pass them separately to matchGenerator and combine their results one after another
+  const selectorsCount = matchParsed.length;
+  if (selectorsCount > 1) {
+    for (const selectorParsed of matchParsed) {
+      yield* matchGenerator(node, [selectorParsed]);
+    }
+
+    return;
+  }
+
+  // For simple selector (matchParsed.length == 0), actual logic starts here
+  {
+    const parsedSelector = matchParsed[0];
+    if (parsedSelector.length === 0) {
+      return;
+    }
+
+    let currentMatchingNodes: FiberNode[] = [node];
+    let currentMatchingSelectorPartIndex = 0;
+    let currentMatchingSelectorPart: CSSwhat.Selector =
+      parsedSelector[currentMatchingSelectorPartIndex];
+    let lastRelationshipSelectorPart: CSSwhat.Selector | undefined = undefined;
+
+    while (currentMatchingSelectorPartIndex < parsedSelector.length) {
+      const nextMatchingNodes: FiberNode[] = [];
+
+      for (const currentNode of currentMatchingNodes) {
+        if (["tag"].includes(currentMatchingSelectorPart.type)) {
+          const traverseIterator = traverseGenerator(currentNode);
+
+          // Handle supported non-traversal parts here
+          if (currentMatchingSelectorPart.type == "tag") {
+            for (const tmpNode of traverseIterator) {
+              if (
+                isNodeNotHtmlLike(tmpNode) &&
+                tmpNode.type.name === currentMatchingSelectorPart.name
+              ) {
+                nextMatchingNodes.push(tmpNode);
+              }
+            }
+          }
+          traverseIterator.throw &&
+            traverseIterator.throw(new Error("cleanup"));
+        } else if (["descendant"].includes(currentMatchingSelectorPart.type)) {
+          // Handle traversal parts here
+          lastRelationshipSelectorPart = currentMatchingSelectorPart;
+        } else {
+          // For unhandled parts
+          lastRelationshipSelectorPart = undefined;
+        }
+      }
+
+      currentMatchingNodes = nextMatchingNodes;
+    }
+
+    return;
+  }
+}
+
+export { matchGenerator };