graphmatch 1.0.2 → 1.1.0

package/dist/types.d.ts

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

package/dist/utils.js

@@ -36,22 +36,24 @@ const getNodeSourceWithCache = (node, partial, cache) => {
     const cached = cache.get(node);
     if (cached !== undefined)
         return cached;
+    const isNodePartial = node.partial ?? partial;
     let source = '';
     if (node.regex) {
-        source += partial ? '(?:$|' : '';
+        source += isNodePartial ? '(?:$|' : '';
         source += node.regex.source;
     }
     if (node.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 ? '(?:$|' : '(?:' : '';
+            const isSomeChildNonPartial = node.children.some(child => !child.regex || !(child.partial ?? partial));
+            const needsWrapperGroup = (children.length > 1) || (isNodePartial && (!source.length || isSomeChildNonPartial));
+            source += needsWrapperGroup ? isNodePartial ? '(?:$|' : '(?:' : '';
             source += children.join('|');
             source += needsWrapperGroup ? ')' : '';
         }
     }
     if (node.regex) {
-        source += partial ? ')' : '';
+        source += isNodePartial ? ')' : '';
     }
     cache.set(node, source);
     return source;

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.2",
+  "version": "1.1.0",
   "type": "module",
   "main": "dist/index.js",
   "exports": "./dist/index.js",

package/readme.md

@@ -3,6 +3,7 @@
 A low-level utility for matching a string against a directed acyclic graph of regexes.
 
 - It supports matching strings partially too.
+- It supports fine-grained control over which nodes in the graph can be matched partially or not.
 - It supports compiling the whole graph to a regex, even for partial matches.
 - The graph will always be matched against the input string from the very start.
 - RegExp flags are supported as long as they are the same for all the regexes in the graph.
@@ -68,7 +69,7 @@ graphmatch ( GRAPH, 'foo/bar/whoops' ); // => false
 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
+// A partial match happens when any node in the graph sees the end of the string, either before or after the node's regex is executed
 
 graphmatch ( GRAPH, 'foo/bar/qux', { partial: true } ); // => true
 graphmatch ( GRAPH, 'foo/bar/', { partial: true } ); // => true
@@ -80,6 +81,24 @@ graphmatch ( GRAPH, 'foo/bar/whoops', { partial: true } ); // => false
 graphmatch ( GRAPH, 'foo/barsomething', { partial: true } ); // => false
 graphmatch ( GRAPH, 'bar', { partial: true } ); // => false
 
+// As we just saw partial matching is set to "false" by default, and there is an option to set it to "true" by default
+// But you can also decide on a node-by-node basis whether partial matching should be enabled or disabled for that particular node
+// A partial node will match if the whole input string has been consumed, right before or after the node's regex is executed
+// This has higher priority compared to the global setting
+// This is useful for fine-grained control over which nodes can be matched partially
+
+const NODE_NEVER_PARTIAL = { // This node will never match partially
+  partial: false,
+  regex: /foo/,
+  children: [],
+};
+
+const NODE_ALWAYS_PARTIAL = { // This node will always match partially
+  partial: true,
+  regex: /foo/,
+  children: [],
+};
+
 // 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