graphmatch 1.0.1 → 1.0.2

package/dist/types.d.ts

@@ -1,6 +1,9 @@
 type Node = {
-    regex?: RegExp;
+    regex: RegExp;
     children?: Node[];
+} | {
+    regex?: RegExp;
+    children: Node[];
 };
 type Options = {
     partial?: boolean;

package/dist/utils.d.ts

@@ -1,5 +1,4 @@
 import type { Node } from './types.js';
 declare const getNodeFlags: (node: Node) => string;
 declare const getNodeSource: (node: Node, partial: boolean) => string;
-declare const visitNode: (node: Node, visitor: (node: Node) => void) => void;
-export { getNodeFlags, getNodeSource, visitNode };
+export { getNodeFlags, getNodeSource };

package/dist/utils.js

@@ -1,27 +1,49 @@
 /* IMPORT */
 /* MAIN */
+const getNodes = (node) => {
+    const nodes = new Set();
+    const queue = [node];
+    for (let i = 0; i < queue.length; i++) {
+        const node = queue[i];
+        if (nodes.has(node))
+            continue;
+        nodes.add(node);
+        const { children } = node;
+        if (!children?.length)
+            continue;
+        for (let ci = 0, cl = children.length; ci < cl; ci++) {
+            queue.push(children[ci]);
+        }
+    }
+    return Array.from(nodes);
+};
 const getNodeFlags = (node) => {
     let flags = '';
-    visitNode(node, node => {
+    const nodes = getNodes(node);
+    for (let i = 0, l = nodes.length; i < l; i++) { // From root to leaves
+        const node = nodes[i];
         if (!node.regex)
-            return;
+            continue;
         const nodeFlags = node.regex.flags;
         flags || (flags = nodeFlags);
-        if (flags !== nodeFlags) {
-            throw new Error(`Inconsistent RegExp flags used: "${flags}" and "${nodeFlags}"`);
-        }
-    });
+        if (flags === nodeFlags)
+            continue;
+        throw new Error(`Inconsistent RegExp flags used: "${flags}" and "${nodeFlags}"`);
+    }
     return flags;
 };
-const getNodeSource = (node, partial) => {
+const getNodeSourceWithCache = (node, partial, cache) => {
+    const cached = cache.get(node);
+    if (cached !== undefined)
+        return cached;
     let source = '';
     if (node.regex) {
         source += partial ? '(?:$|' : '';
         source += node.regex.source;
     }
     if (node.children?.length) {
-        const children = node.children.map(node => getNodeSource(node, partial)).filter(Boolean);
-        if (children.length) {
+        const children = uniq(node.children.map(node => getNodeSourceWithCache(node, partial, cache)).filter(Boolean));
+        if (children?.length) {
             const needsWrapperGroup = (children.length > 1) || (partial && !source.length);
             source += needsWrapperGroup ? partial ? '(?:$|' : '(?:' : '';
             source += children.join('|');
@@ -31,13 +53,22 @@ const getNodeSource = (node, partial) => {
     if (node.regex) {
         source += partial ? ')' : '';
     }
+    cache.set(node, source);
     return source;
 };
-const visitNode = (node, visitor) => {
-    visitor(node);
-    node.children?.forEach(node => {
-        visitNode(node, visitor);
-    });
+const getNodeSource = (node, partial) => {
+    const cache = new Map();
+    const nodes = getNodes(node);
+    for (let i = nodes.length - 1; i >= 0; i--) { // From leaves to root
+        const source = getNodeSourceWithCache(nodes[i], partial, cache);
+        if (i > 0)
+            continue;
+        return source;
+    }
+    return '';
+};
+const uniq = (values) => {
+    return Array.from(new Set(values));
 };
 /* EXPORT */
-export { getNodeFlags, getNodeSource, visitNode };
+export { getNodeFlags, getNodeSource };

package/package.json

@@ -2,7 +2,7 @@
   "name": "graphmatch",
   "repository": "github:fabiospampinato/graphmatch",
   "description": "A low-level utility for matching a string against a directed acyclic graph of regexes.",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "module",
   "main": "dist/index.js",
   "exports": "./dist/index.js",

package/asd.js

@@ -1,81 +0,0 @@
-
-import graphmatch from './dist/index.js';
-
-
-const GRAPH = {
-  regex: /foo/,
-  children: [
-    {
-      regex: /\//,
-      children: [
-        {
-          regex: /bar/,
-          children: [
-            {
-              regex: /\//,
-              children: [
-                {
-                  regex: /qux/
-                }
-              ]
-            }
-          ]
-        },
-        {
-          regex: /baz/,
-          children: [
-            {
-              regex: /\//,
-              children: [
-                {
-                  regex: /qux/
-                }
-              ]
-            }
-          ]
-        }
-      ]
-    }
-  ]
-};
-
-// Let's now match against the graph, fully
-
-console.log ('1.');
-
-console.log ( graphmatch ( GRAPH, 'foo/bar/qux' ) ); // => true
-console.log ( graphmatch ( GRAPH, 'foo/baz/qux' ) ); // => true
-
-console.log ( graphmatch ( GRAPH, 'foo/bar/whoops' ) ); // => false
-console.log ( graphmatch ( GRAPH, 'foo/baz' ) ); // => false
-
-// Let's now match against the graph, partially
-// A partial match happens when any matching node in the graph reaches the end of the string
-
-console.log ('2.');
-
-console.log ( graphmatch ( GRAPH, 'foo/bar/qux', { partial: true } ) ); // => true
-console.log ( graphmatch ( GRAPH, 'foo/bar/', { partial: true } ) ); // => true
-console.log ( graphmatch ( GRAPH, 'foo/bar', { partial: true } ) ); // => true
-console.log ( graphmatch ( GRAPH, 'foo/', { partial: true } ) ); // => true
-console.log ( graphmatch ( GRAPH, 'foo', { partial: true } ) ); // => true
-
-console.log ( graphmatch ( GRAPH, 'foo/bar/whoops', { partial: true } ) ); // => false
-console.log ( graphmatch ( GRAPH, 'foo/barsomething', { partial: true } ) ); // => false
-console.log ( graphmatch ( GRAPH, 'bar', { partial: true } ) ); // => false
-
-// Let's now compile the whole graph to a single regex
-// This is useful if you expect to match against the graph multiple times
-// It's faster to compile the graph once and match against it multiple times
-
-console.log ('3.');
-
-const fullRe = graphmatch.compile ( GRAPH ); // => RegExp
-
-console.log ( fullRe.test ( 'foo/bar/qux' ) ); // => true
-console.log ( fullRe.test ( 'foo/bar' ) ); // => false
-
-const partialRe = graphmatch.compile ( GRAPH, { partial: true } ); // => RegExp
-
-console.log ( partialRe.test ( 'foo/bar/qux' ) ); // => true
-console.log ( partialRe.test ( 'foo/bar' ) ); // => true