@wix/web5-core 1.56.0

package/dist/cjs/patternValidator/matcher.js

@@ -0,0 +1,722 @@
+"use strict";
+
+exports.__esModule = true;
+exports.elementMatchesStop = elementMatchesStop;
+exports.match = match;
+var _automaton = require("./automaton");
+function parseListFromElement(element) {
+  const elementStr = element;
+  if (!elementStr.startsWith('list{')) {
+    return null;
+  }
+  const listMatch = elementStr.match(/^list\{(.+)\}$/);
+  if (!listMatch) {
+    return null;
+  }
+  const content = listMatch[1];
+  const items = [];
+  let i = 0;
+
+  // Handle double bracket format: [[item1], [item2]]
+  while (i < content.length) {
+    if (content[i] === '[') {
+      i++; // skip first [
+      let depth = 1;
+      let itemContent = '';
+      while (i < content.length && depth > 0) {
+        if (content[i] === '[') {
+          depth++;
+        }
+        if (content[i] === ']') {
+          depth--;
+        }
+        if (depth > 0) {
+          itemContent += content[i];
+        }
+        i++;
+      }
+      const elements = itemContent.split(',').map(e => e.trim()).filter(e => e);
+      if (elements.length > 0) {
+        items.push(elements);
+      }
+    } else {
+      i++;
+    }
+  }
+  return items.length > 0 ? items : null;
+}
+function findAllListPatterns(node) {
+  // Create a map of list element signatures to their pattern nodes
+  // This handles lists that appear multiple times due to quantifiers
+  const listPatterns = new Map();
+  function traverse(n) {
+    if (n.kind === 'list') {
+      // Use the list structure as a key (simplified - in reality all lists use same structure)
+      const key = 'list';
+      if (!listPatterns.has(key)) {
+        listPatterns.set(key, n);
+      }
+    } else if (n.kind === 'sequence') {
+      n.children.forEach(traverse);
+    } else if (n.kind === 'alternation') {
+      n.choices.forEach(traverse);
+    } else if (n.kind === 'group') {
+      traverse(n.pattern);
+    }
+  }
+  traverse(node);
+  return listPatterns;
+}
+function validateListItems(items, itemCount, itemStructure, enrichedItems) {
+  // Validate item count
+  if (itemCount) {
+    const min = itemCount.min ?? 0;
+    const max = itemCount.max ?? Infinity;
+    if (items.length < min || items.length > max) {
+      const minStr = min === 0 ? '0' : min.toString();
+      const maxStr = max === Infinity ? 'unlimited' : max.toString();
+      const rangeStr = min === max ? `exactly ${min}` : `between ${minStr} and ${maxStr}`;
+      return {
+        valid: false,
+        error: `Expected ${rangeStr} items in list, but got ${items.length} items`,
+        startIndex: 0,
+        endIndex: -1
+      };
+    }
+  }
+
+  // Validate each item structure
+  if (itemStructure) {
+    for (let i = 0; i < items.length; i++) {
+      const enrichedItem = enrichedItems == null ? void 0 : enrichedItems[i];
+      const result = validateItemStructure(items[i], itemStructure, i, enrichedItem);
+      if (!result.valid) {
+        return result;
+      }
+    }
+  }
+  return {
+    valid: true,
+    startIndex: 0,
+    endIndex: items.length > 0 ? items.length - 1 : -1
+  };
+}
+function validateItemStructure(item, pattern, itemIndex, enrichedItem) {
+  // Build automaton for the item pattern
+  const automaton = (0, _automaton.buildAutomaton)(pattern);
+  let isValid;
+  if (enrichedItem) {
+    // Use full match with metadata for attribute checking (e.g., link[entityType="solution"])
+    const matchResult = match(automaton, enrichedItem, pattern);
+    // Require full match: all elements must be consumed (no extra trailing elements)
+    isValid = matchResult.valid && matchResult.endIndex === enrichedItem.length - 1;
+  } else {
+    // Fallback: use simple matching without metadata
+    isValid = matchSimple(automaton, item);
+  }
+  if (!isValid) {
+    const patternStr = formatPatternNode(pattern);
+    return {
+      valid: false,
+      error: `Item #${itemIndex + 1} [${item.join(', ')}] does not match expected pattern: ${patternStr}`,
+      startIndex: 0,
+      endIndex: -1
+    };
+  }
+  return {
+    valid: true,
+    startIndex: 0,
+    endIndex: item.length > 0 ? item.length - 1 : -1
+  };
+}
+function formatPatternNode(node) {
+  switch (node.kind) {
+    case 'element':
+      return node.element + formatQuantifier(node.quantifier);
+    case 'sequence':
+      return node.children.map(formatPatternNode).join(' > ');
+    case 'alternation':
+      return node.choices.map(formatPatternNode).join(' | ');
+    case 'group':
+      return '(' + formatPatternNode(node.pattern) + ')' + formatQuantifier(node.quantifier);
+    case 'list':
+      return 'list{...}';
+    default:
+      return '?';
+  }
+}
+function formatQuantifier(quantifier) {
+  if (!quantifier) {
+    return '';
+  }
+  switch (quantifier.type) {
+    case 'star':
+      return '*';
+    case 'plus':
+      return '+';
+    case 'optional':
+      return '?';
+    case 'exact':
+      return `[${quantifier.min}]`;
+    case 'range':
+      if (quantifier.min === undefined) {
+        return `[-${quantifier.max}]`;
+      }
+      if (quantifier.max === undefined) {
+        return `[${quantifier.min}-]`;
+      }
+      return `[${quantifier.min}-${quantifier.max}]`;
+    default:
+      return '';
+  }
+}
+function matchSimple(automaton, elements) {
+  function epsilonClosure(stateIds) {
+    const closure = new Set(stateIds);
+    const stack = Array.from(stateIds);
+    while (stack.length > 0) {
+      const state = stack.pop();
+      for (const transition of automaton.transitions) {
+        if (transition.from === state && transition.condition.type === 'epsilon' && !closure.has(transition.to)) {
+          closure.add(transition.to);
+          stack.push(transition.to);
+        }
+      }
+    }
+    return closure;
+  }
+  function getNextStates(currentStates, element) {
+    const nextStates = new Set();
+    for (const state of currentStates) {
+      for (const transition of automaton.transitions) {
+        if (transition.from === state && matchesCondition(transition.condition, element)) {
+          nextStates.add(transition.to);
+        }
+      }
+    }
+    return nextStates;
+  }
+  function matchesCondition(condition, element) {
+    if (condition.type === 'element') {
+      return condition.element === element;
+    }
+    return false;
+  }
+  let currentStates = epsilonClosure(new Set([automaton.startState]));
+  for (const element of elements) {
+    const nextStates = getNextStates(currentStates, element);
+    if (nextStates.size === 0) {
+      return false;
+    }
+    currentStates = epsilonClosure(nextStates);
+  }
+  for (const state of currentStates) {
+    if (automaton.acceptStates.has(state)) {
+      return true;
+    }
+  }
+  return false;
+}
+function validateLinkAttributes(metadata, requiredAttrs) {
+  if (!metadata) {
+    // If metadata is missing but attributes are required, return false
+    return requiredAttrs.length === 0;
+  }
+
+  // Build a record of all available attributes from LinkMetadata
+  const availableAttrs = {
+    url: metadata.url,
+    protocol: metadata.protocol,
+    web5Type: metadata.web5Type,
+    entityType: metadata.entityType,
+    entityId: metadata.entityId
+  };
+
+  // Validate each required attribute
+  for (const attr of requiredAttrs) {
+    const value = availableAttrs[attr.key];
+    switch (attr.operator) {
+      case 'exists':
+        // Check if key exists and has a non-undefined value
+        if (value === undefined) {
+          return false;
+        }
+        break;
+      case 'equals':
+        // Case-insensitive comparison for entityType, exact match for others
+        if (attr.key === 'entityType') {
+          var _attr$value;
+          if ((value == null ? void 0 : value.toLowerCase()) !== ((_attr$value = attr.value) == null ? void 0 : _attr$value.toLowerCase())) {
+            return false;
+          }
+        } else if (value !== attr.value) {
+          return false;
+        }
+        break;
+      case 'contains':
+        // Check if value contains substring
+        if (value === undefined || !attr.value || !value.includes(attr.value)) {
+          return false;
+        }
+        break;
+      case 'startsWith':
+        // Check if value starts with prefix
+        if (value === undefined || !attr.value || !value.startsWith(attr.value)) {
+          return false;
+        }
+        break;
+      case 'endsWith':
+        // Check if value ends with suffix
+        if (value === undefined || !attr.value || !value.endsWith(attr.value)) {
+          return false;
+        }
+        break;
+    }
+  }
+  return true;
+}
+function validateImageAttributes(metadata, requiredAttrs) {
+  if (!metadata) {
+    return requiredAttrs.length === 0;
+  }
+  const availableAttrs = {
+    src: metadata.src,
+    alt: metadata.alt,
+    type: metadata.type
+  };
+  for (const attr of requiredAttrs) {
+    const value = availableAttrs[attr.key];
+    switch (attr.operator) {
+      case 'exists':
+        if (value === undefined) {
+          return false;
+        }
+        break;
+      case 'equals':
+        if (value !== attr.value) {
+          return false;
+        }
+        break;
+      case 'contains':
+        if (value === undefined || !attr.value || !value.includes(attr.value)) {
+          return false;
+        }
+        break;
+      case 'startsWith':
+        if (value === undefined || !attr.value || !value.startsWith(attr.value)) {
+          return false;
+        }
+        break;
+      case 'endsWith':
+        if (value === undefined || !attr.value || !value.endsWith(attr.value)) {
+          return false;
+        }
+        break;
+    }
+  }
+  return true;
+}
+function validateHtmlCommentAttributes(metadata, requiredAttrs) {
+  if (!metadata) {
+    // If metadata is missing, no attributes can exist
+    return requiredAttrs.length === 0;
+  }
+
+  // Validate each required attribute
+  for (const attr of requiredAttrs) {
+    const value = metadata[attr.key];
+    switch (attr.operator) {
+      case 'exists':
+        // Check if key exists in metadata
+        if (!(attr.key in metadata)) {
+          return false;
+        }
+        break;
+      case 'equals':
+        // Check if value equals exactly
+        if (value !== attr.value) {
+          return false;
+        }
+        break;
+      case 'contains':
+        // Check if value contains substring
+        if (!value || !attr.value || !value.includes(attr.value)) {
+          return false;
+        }
+        break;
+      case 'startsWith':
+        // Check if value starts with prefix
+        if (!value || !attr.value || !value.startsWith(attr.value)) {
+          return false;
+        }
+        break;
+      case 'endsWith':
+        // Check if value ends with suffix
+        if (!value || !attr.value || !value.endsWith(attr.value)) {
+          return false;
+        }
+        break;
+    }
+  }
+  return true;
+}
+
+/**
+ * Checks whether an enriched block element satisfies a pattern's `~` stop
+ * condition (element type plus optional attribute selectors).
+ */
+function elementMatchesStop(enrichedElement, stop) {
+  // List elements may carry an inline structure (e.g. 'list{[t],[t]}')
+  const elementType = enrichedElement.element.startsWith('list') ? 'list' : enrichedElement.element;
+  if (elementType !== stop.element) {
+    return false;
+  }
+  if (stop.htmlCommentAttrs) {
+    return validateHtmlCommentAttributes(enrichedElement.htmlCommentMetadata, stop.htmlCommentAttrs);
+  }
+  if (stop.linkAttrs) {
+    return validateLinkAttributes(enrichedElement.linkMetadata, stop.linkAttrs);
+  }
+  if (stop.imageAttrs) {
+    return validateImageAttributes(enrichedElement.imageMetadata, stop.imageAttrs);
+  }
+  return true;
+}
+function match(automaton, elements, ast) {
+  function epsilonClosure(stateIds) {
+    const closure = new Set(stateIds);
+    const stack = Array.from(stateIds);
+    while (stack.length > 0) {
+      const state = stack.pop();
+      for (const transition of automaton.transitions) {
+        if (transition.from === state && transition.condition.type === 'epsilon' && !closure.has(transition.to)) {
+          closure.add(transition.to);
+          stack.push(transition.to);
+        }
+      }
+    }
+    return closure;
+  }
+  function getNextStates(currentStates, enrichedElement, patternNode) {
+    const nextStates = new Set();
+    for (const state of currentStates) {
+      for (const transition of automaton.transitions) {
+        if (transition.from === state && matchesCondition(transition.condition, enrichedElement, patternNode)) {
+          nextStates.add(transition.to);
+        }
+      }
+    }
+    return nextStates;
+  }
+  function matchesCondition(condition, enrichedElement, _patternNode) {
+    if (condition.type === 'element') {
+      const element = enrichedElement.element;
+
+      // Check if element type matches
+      if (condition.element !== element) {
+        return false;
+      }
+
+      // If this is an html_comment element, check HTML comment attributes from the transition
+      if (element === 'html_comment' && condition.htmlCommentAttrs) {
+        return validateHtmlCommentAttributes(enrichedElement.htmlCommentMetadata, condition.htmlCommentAttrs);
+      }
+
+      // If this is a link element, check link attributes from the transition
+      if (element === 'link' && condition.linkAttrs) {
+        return validateLinkAttributes(enrichedElement.linkMetadata, condition.linkAttrs);
+      }
+
+      // If this is an image element, check image attributes from the transition
+      if (element === 'image' && condition.imageAttrs) {
+        return validateImageAttributes(enrichedElement.imageMetadata, condition.imageAttrs);
+      }
+      return true;
+    }
+    return false;
+  }
+
+  // Helper function to find all pattern nodes for a given element type
+  function findAllPatternNodesForElement(elementType, pattern) {
+    const results = [];
+    function traverse(node) {
+      if (node.kind === 'element' && node.element === elementType) {
+        results.push(node);
+      }
+      if (node.kind === 'sequence') {
+        for (const child of node.children) {
+          traverse(child);
+        }
+      }
+      if (node.kind === 'alternation') {
+        for (const choice of node.choices) {
+          traverse(choice);
+        }
+      }
+      if (node.kind === 'group') {
+        traverse(node.pattern);
+      }
+    }
+    traverse(pattern);
+    return results;
+  }
+
+  // Helper function to find the first matching pattern node for an element
+  // If multiple exist, we check them all and return the first that matches attributes (if any)
+  function findPatternNodeForElement(elementType, pattern, enrichedElement) {
+    const matchingNodes = findAllPatternNodesForElement(elementType, pattern);
+    if (matchingNodes.length === 0) {
+      return undefined;
+    }
+    if (matchingNodes.length === 1) {
+      return matchingNodes[0];
+    }
+    // If multiple pattern nodes exist, find one that matches attributes (if element has attributes)
+    if (elementType === 'html_comment' && enrichedElement.htmlCommentMetadata) {
+      for (const node of matchingNodes) {
+        if (node.kind === 'element' && node.htmlCommentAttrs) {
+          if (validateHtmlCommentAttributes(enrichedElement.htmlCommentMetadata, node.htmlCommentAttrs)) {
+            return node;
+          }
+        }
+      }
+    }
+    // If multiple pattern nodes exist for link, find one that matches link attributes
+    if (elementType === 'link' && enrichedElement.linkMetadata) {
+      for (const node of matchingNodes) {
+        if (node.kind === 'element' && node.linkAttrs) {
+          if (validateLinkAttributes(enrichedElement.linkMetadata, node.linkAttrs)) {
+            return node;
+          }
+        }
+      }
+    }
+    // If multiple pattern nodes exist for image, find one that matches image attributes
+    if (elementType === 'image' && enrichedElement.imageMetadata) {
+      for (const node of matchingNodes) {
+        if (node.kind === 'element' && node.imageAttrs) {
+          if (validateImageAttributes(enrichedElement.imageMetadata, node.imageAttrs)) {
+            return node;
+          }
+        }
+      }
+    }
+    // Return first matching node if no attribute match found
+    return matchingNodes[0];
+  }
+
+  // Extract list patterns from AST if provided
+  // Use a map so the same pattern applies to all list instances
+  const listPatterns = ast ? findAllListPatterns(ast) : new Map();
+  const defaultListPattern = listPatterns.get('list');
+  let currentStates = epsilonClosure(new Set([automaton.startState]));
+  let elementIndex = 0;
+  let lastValidIndex = -1; // Track the last successfully matched element index
+  let lastAcceptStateIndex = -1; // Track when we were last in an accept state
+
+  // Handle empty array case
+  if (elements.length === 0) {
+    // Check if empty array is acceptable (pattern allows zero elements)
+    for (const state of currentStates) {
+      if (automaton.acceptStates.has(state)) {
+        return {
+          valid: true,
+          startIndex: 0,
+          endIndex: -1
+        };
+      }
+    }
+    return {
+      valid: false,
+      error: 'Empty array does not match pattern',
+      startIndex: 0,
+      endIndex: -1
+    };
+  }
+  for (const enrichedElement of elements) {
+    // Check if we're already in an accept state before processing this element
+    // If so, this element is extra and we can accept it
+    let isInAcceptState = false;
+    for (const state of currentStates) {
+      if (automaton.acceptStates.has(state)) {
+        isInAcceptState = true;
+        break;
+      }
+    }
+
+    // Also check if we were in an accept state before starting to match incomplete elements
+    // This handles cases where we matched some elements after being in an accept state,
+    // but those elements didn't complete the pattern
+    const wasInAcceptStateBefore = lastAcceptStateIndex >= 0 && elementIndex > lastAcceptStateIndex;
+    const element = enrichedElement.element;
+    // Check if this is a list element
+    const listItems = parseListFromElement(element);
+    if (listItems !== null && defaultListPattern) {
+      // Validate list items using the pattern
+      const validationResult = validateListItems(listItems, defaultListPattern.itemCount, defaultListPattern.itemStructure, enrichedElement.listItemsEnriched);
+      if (!validationResult.valid) {
+        return {
+          valid: false,
+          error: `List at position ${elementIndex + 1} failed validation: ${validationResult.error}`,
+          startIndex: 0,
+          endIndex: lastValidIndex
+        };
+      }
+
+      // Continue matching with 'list' as element type
+      const listPatternNode = ast ? findPatternNodeForElement('list', ast, {
+        element: 'list',
+        astNodeIndex: enrichedElement.astNodeIndex
+      }) : undefined;
+      const nextStates = getNextStates(currentStates, {
+        element: 'list',
+        astNodeIndex: enrichedElement.astNodeIndex
+      }, listPatternNode);
+      if (nextStates.size === 0) {
+        // No transitions - if we were already in accept state, extra elements are OK
+        if (isInAcceptState || wasInAcceptStateBefore) {
+          // Pattern was fully matched, extra elements are OK
+          return {
+            valid: true,
+            startIndex: 0,
+            endIndex: lastAcceptStateIndex >= 0 ? lastAcceptStateIndex : lastValidIndex
+          };
+        }
+        return {
+          valid: false,
+          error: `Unexpected list at position ${elementIndex + 1}. Pattern does not expect a list here.`,
+          startIndex: 0,
+          endIndex: lastValidIndex
+        };
+      }
+      currentStates = epsilonClosure(nextStates);
+      // Successfully matched this element
+      lastValidIndex = elementIndex;
+
+      // Check if we're now in an accept state (after matching list)
+      for (const state of currentStates) {
+        if (automaton.acceptStates.has(state)) {
+          lastAcceptStateIndex = elementIndex;
+          break;
+        }
+      }
+    } else if (listItems !== null) {
+      // List without validation pattern - just match as 'list'
+      const listPatternNode = ast ? findPatternNodeForElement('list', ast, {
+        element: 'list',
+        astNodeIndex: enrichedElement.astNodeIndex
+      }) : undefined;
+      const nextStates = getNextStates(currentStates, {
+        element: 'list',
+        astNodeIndex: enrichedElement.astNodeIndex
+      }, listPatternNode);
+      if (nextStates.size === 0) {
+        // No transitions - if we were already in accept state, extra elements are OK
+        if (isInAcceptState || wasInAcceptStateBefore) {
+          // Pattern was fully matched, extra elements are OK
+          return {
+            valid: true,
+            startIndex: 0,
+            endIndex: lastAcceptStateIndex >= 0 ? lastAcceptStateIndex : lastValidIndex
+          };
+        }
+        return {
+          valid: false,
+          error: `Unexpected list at position ${elementIndex + 1}. Pattern does not expect a list here.`,
+          startIndex: 0,
+          endIndex: lastValidIndex
+        };
+      }
+      currentStates = epsilonClosure(nextStates);
+      // Successfully matched this element
+      lastValidIndex = elementIndex;
+
+      // Check if we're now in an accept state (after matching list without pattern)
+      for (const state of currentStates) {
+        if (automaton.acceptStates.has(state)) {
+          lastAcceptStateIndex = elementIndex;
+          break;
+        }
+      }
+    } else {
+      // Regular element matching
+      const elementPatternNode = ast ? findPatternNodeForElement(element, ast, enrichedElement) : undefined;
+      const nextStates = getNextStates(currentStates, enrichedElement, elementPatternNode);
+      if (nextStates.size === 0) {
+        // No transitions - if we were already in accept state, extra elements are OK
+        if (isInAcceptState || wasInAcceptStateBefore) {
+          // Pattern was fully matched, extra elements are OK
+          return {
+            valid: true,
+            startIndex: 0,
+            endIndex: lastAcceptStateIndex >= 0 ? lastAcceptStateIndex : lastValidIndex
+          };
+        }
+        return {
+          valid: false,
+          error: `Unexpected element '${element}' at position ${elementIndex + 1}. Pattern does not match.`,
+          startIndex: 0,
+          endIndex: lastValidIndex
+        };
+      }
+
+      // If we're in an accept state and the element matches, check if matching it
+      // leads to a state that can eventually complete the pattern
+      if (isInAcceptState) {
+        // Check if any of the next states are accept states, or can reach accept states
+        // via epsilon transitions (which we already did with epsilonClosure)
+        // If matching this element doesn't immediately lead to an accept state,
+        // it might still be valid if it's part of a larger pattern. But if we're
+        // already in an accept state and this element starts a new pattern that
+        // can't complete, we should treat it as extra.
+        // For now, we'll continue matching and let the pattern fail naturally if incomplete.
+        // The key is that we're in an accept state, so if matching fails, we can backtrack.
+        void epsilonClosure(nextStates);
+      }
+      currentStates = epsilonClosure(nextStates);
+      // Successfully matched this element
+      lastValidIndex = elementIndex;
+
+      // Check if we're now in an accept state (after matching list or any element)
+      for (const state of currentStates) {
+        if (automaton.acceptStates.has(state)) {
+          lastAcceptStateIndex = elementIndex;
+          break;
+        }
+      }
+    }
+    elementIndex++;
+  }
+
+  // Check if any current state is an accept state
+  for (const state of currentStates) {
+    if (automaton.acceptStates.has(state)) {
+      // Complete match - all elements matched
+      return {
+        valid: true,
+        startIndex: 0,
+        endIndex: elements.length - 1
+      };
+    }
+  }
+
+  // Incomplete match - pattern expects more elements but we've processed all
+  // If we were in an accept state at some point, and the incomplete part started
+  // after that point, treat the incomplete part as extra elements
+  if (lastAcceptStateIndex >= 0 && lastValidIndex > lastAcceptStateIndex) {
+    // We were in an accept state, then matched more elements that didn't complete
+    // Treat this as a complete match with extra elements
+    return {
+      valid: true,
+      startIndex: 0,
+      endIndex: lastAcceptStateIndex
+    };
+  }
+  return {
+    valid: false,
+    error: `Pattern matching incomplete. Expected more elements after position ${elementIndex}.`,
+    startIndex: 0,
+    endIndex: lastValidIndex
+  };
+}
+//# sourceMappingURL=matcher.js.map