@lvce-editor/find-widget-worker 3.18.0 → 3.20.0

package/dist/findWidgetWorkerMain.js

@@ -995,6 +995,7 @@ const Button = 1;
 const Div = 4;
 const Text = 12;
 const TextArea = 62;
+const Reference = 100;
 
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
@@ -1020,6 +1021,7 @@ const FocusSelector = 'Viewlet.focusSelector';
 const SetCss = 'Viewlet.setCss';
 const SetFocusContext = 'Viewlet.setFocusContext';
 const SetValueByName = 'Viewlet.setValueByName';
+const SetPatches = 'Viewlet.setPatches';
 
 const Empty = 0;
 const FocusFindWidget$1 = 16;
@@ -1488,7 +1490,7 @@ const isEqual$4 = (oldState, newState) => {
 };
 
 const isEqual$3 = (oldState, newState) => {
-  return oldState.inputErrorMessage === newState.inputErrorMessage && oldState.matchCase === newState.matchCase && oldState.matchCount === newState.matchCount && oldState.matchIndex === newState.matchIndex && oldState.matchWholeWord === newState.matchWholeWord && oldState.preserveCase === newState.preserveCase && oldState.replaceExpanded === newState.replaceExpanded && oldState.useRegularExpression === newState.useRegularExpression && oldState.version === newState.version;
+  return oldState.inputErrorMessage === newState.inputErrorMessage && oldState.focus === newState.focus && oldState.matchCase === newState.matchCase && oldState.matchCount === newState.matchCount && oldState.matchIndex === newState.matchIndex && oldState.matchWholeWord === newState.matchWholeWord && oldState.preserveCase === newState.preserveCase && oldState.replaceExpanded === newState.replaceExpanded && oldState.useRegularExpression === newState.useRegularExpression && oldState.value === newState.value && oldState.version === newState.version;
 };
 
 const isEqual$2 = (oldState, newState) => {
@@ -1706,9 +1708,13 @@ const buildRegex = (searchString, options) => {
 
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types -- Appends matches to the shared output array.
 const collectMatchesForLineInternal = (matches, line, lineIndex, regex) => {
+  regex.lastIndex = 0;
   let lastMatch = regex.exec(line);
   while (lastMatch) {
     matches.push(lineIndex, lastMatch.index, lastMatch[0].length);
+    if (lastMatch[0].length === 0) {
+      regex.lastIndex = lastMatch.index + 1;
+    }
     lastMatch = regex.exec(line);
   }
 };
@@ -1887,7 +1893,7 @@ const FocusPrevious = 'FocusPrevious';
 const MatchCase$2 = 'MatchCase';
 const MatchWholeWord$2 = 'MatchWholeWord';
 const PreserveCase$1 = 'PreserveCase';
-const Replace$2 = 'Replace';
+const Replace$3 = 'Replace';
 const ReplaceAll$2 = 'ReplaceAll';
 const ReplaceValue = 'replace-value';
 const SearchValue = 'search-value';
@@ -2142,7 +2148,7 @@ const getClickHandler = name => {
       return toggleMatchWholeWord;
     case PreserveCase$1:
       return togglePreserveCase;
-    case Replace$2:
+    case Replace$3:
       return replace$1;
     case ReplaceAll$2:
       return replaceAll$1;
@@ -2167,7 +2173,7 @@ const getFindWidgetFocusKey = name => {
       return FocusSearchWholeWord;
     case PreserveCase$1:
       return FocusSearchPreserveCase;
-    case Replace$2:
+    case Replace$3:
       return FocusFindWidgetReplaceButton$1;
     case ReplaceAll$2:
       return FocusFindWidgetReplaceAllButton$1;
@@ -2685,6 +2691,343 @@ const renderBounds = (oldState, newState) => {
   return [SetBounds, uid, x, y, width, height];
 };
 
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+
+const text = data => {
+  return {
+    childCount: 0,
+    text: data,
+    type: Text
+  };
+};
+
+const SetText = 1;
+const Replace$2 = 2;
+const SetAttribute = 3;
+const RemoveAttribute = 4;
+const Add = 6;
+const NavigateChild = 7;
+const NavigateParent = 8;
+const RemoveChild = 9;
+const NavigateSibling = 10;
+const SetReferenceNodeUid = 11;
+const MultiNavigation = 18;
+
+const isKey = key => {
+  return key !== 'type' && key !== 'childCount';
+};
+
+const getKeys = node => {
+  const keys = Object.keys(node).filter(isKey);
+  return keys;
+};
+
+const arrayToTree = nodes => {
+  const result = [];
+  let i = 0;
+  while (i < nodes.length) {
+    const node = nodes[i];
+    const {
+      children,
+      nodesConsumed
+    } = getChildrenWithCount(nodes, i + 1, node.childCount || 0);
+    result.push({
+      node,
+      children
+    });
+    i += 1 + nodesConsumed;
+  }
+  return result;
+};
+const getChildrenWithCount = (nodes, startIndex, childCount) => {
+  if (childCount === 0) {
+    return {
+      children: [],
+      nodesConsumed: 0
+    };
+  }
+  const children = [];
+  let i = startIndex;
+  let remaining = childCount;
+  let totalConsumed = 0;
+  while (remaining > 0 && i < nodes.length) {
+    const node = nodes[i];
+    const nodeChildCount = node.childCount || 0;
+    const {
+      children: nodeChildren,
+      nodesConsumed
+    } = getChildrenWithCount(nodes, i + 1, nodeChildCount);
+    children.push({
+      node,
+      children: nodeChildren
+    });
+    const nodeSize = 1 + nodesConsumed;
+    i += nodeSize;
+    totalConsumed += nodeSize;
+    remaining--;
+  }
+  return {
+    children,
+    nodesConsumed: totalConsumed
+  };
+};
+
+const isNavigationPatch = patch => {
+  switch (patch.type) {
+    case NavigateChild:
+    case NavigateParent:
+    case NavigateSibling:
+      return true;
+    default:
+      return false;
+  }
+};
+const getNavigationIndex = patch => {
+  switch (patch.type) {
+    case NavigateChild:
+    case NavigateSibling:
+      return patch.index;
+    default:
+      return 0;
+  }
+};
+const appendNavigationPatch = (patches, type, index) => {
+  const previousPatch = patches.at(-1);
+  if (!previousPatch) {
+    patches.push(type === NavigateParent ? {
+      type
+    } : {
+      index,
+      type
+    });
+    return;
+  }
+  if (previousPatch.type === MultiNavigation) {
+    previousPatch.navigations.push(type, index);
+    return;
+  }
+  if (isNavigationPatch(previousPatch)) {
+    patches[patches.length - 1] = {
+      navigations: [previousPatch.type, getNavigationIndex(previousPatch), type, index],
+      type: MultiNavigation
+    };
+    return;
+  }
+  patches.push(type === NavigateParent ? {
+    type
+  } : {
+    index,
+    type
+  });
+};
+
+const compareNodes = (oldNode, newNode) => {
+  // Check if node type changed - return null to signal incompatible nodes
+  // (caller should handle this with a Replace operation)
+  if (oldNode.type !== newNode.type) {
+    return null;
+  }
+  const patches = [];
+  // Handle reference nodes - special handling for uid changes
+  if (oldNode.type === Reference && oldNode.uid !== newNode.uid) {
+    patches.push({
+      type: SetReferenceNodeUid,
+      uid: newNode.uid
+    });
+  }
+  // Handle text nodes
+  if (oldNode.type === Text && newNode.type === Text) {
+    if (oldNode.text !== newNode.text) {
+      patches.push({
+        type: SetText,
+        value: newNode.text
+      });
+    }
+    return patches;
+  }
+  // Compare attributes
+  const oldKeys = getKeys(oldNode).filter(key => oldNode.type !== Reference || key !== 'uid');
+  const newKeys = getKeys(newNode).filter(key => newNode.type !== Reference || key !== 'uid');
+  // Check for attribute changes
+  for (const key of newKeys) {
+    if (oldNode[key] !== newNode[key]) {
+      patches.push({
+        type: SetAttribute,
+        key,
+        value: newNode[key]
+      });
+    }
+  }
+  // Check for removed attributes
+  for (const key of oldKeys) {
+    if (!Object.hasOwn(newNode, key)) {
+      patches.push({
+        type: RemoveAttribute,
+        key
+      });
+    }
+  }
+  return patches;
+};
+
+const treeToArray = node => {
+  const result = [];
+  const stack = [node];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    result.push(current.node);
+    for (let i = current.children.length - 1; i >= 0; i--) {
+      stack.push(current.children[i]);
+    }
+  }
+  return result;
+};
+
+const navigateToChild = (patches, currentChildIndex, index) => {
+  if (currentChildIndex === -1) {
+    appendNavigationPatch(patches, NavigateChild, index);
+    return index;
+  }
+  if (currentChildIndex !== index) {
+    appendNavigationPatch(patches, NavigateSibling, index);
+  }
+  return index;
+};
+const navigateToParent = (patches, currentChildIndex) => {
+  if (currentChildIndex >= 0) {
+    appendNavigationPatch(patches, NavigateParent, 0);
+  }
+  return -1;
+};
+const addTree = (newNode, patches) => {
+  patches.push({
+    type: Add,
+    nodes: treeToArray(newNode)
+  });
+};
+const replaceTree = (newNode, patches) => {
+  patches.push({
+    type: Replace$2,
+    nodes: treeToArray(newNode)
+  });
+};
+const appendPatch = (patches, patch) => {
+  switch (patch.type) {
+    case MultiNavigation:
+      for (let i = 0; i < patch.navigations.length; i += 2) {
+        appendNavigationPatch(patches, patch.navigations[i], patch.navigations[i + 1]);
+      }
+      return;
+    case NavigateChild:
+    case NavigateSibling:
+      appendNavigationPatch(patches, patch.type, patch.index);
+      return;
+    case NavigateParent:
+      appendNavigationPatch(patches, patch.type, 0);
+      return;
+    default:
+      patches.push(patch);
+  }
+};
+const appendPatches = (patches, newPatches) => {
+  for (const patch of newPatches) {
+    appendPatch(patches, patch);
+  }
+};
+const diffExistingChild = (oldNode, newNode, patches, currentChildIndex, index) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+    replaceTree(newNode, patches);
+    return nextChildIndex;
+  }
+  const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+  const childPatches = [];
+  if (hasChildrenToCompare) {
+    diffChildren(oldNode.children, newNode.children, childPatches);
+  }
+  if (nodePatches.length === 0 && childPatches.length === 0) {
+    return currentChildIndex;
+  }
+  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+  patches.push(...nodePatches);
+  appendPatches(patches, childPatches);
+  return nextChildIndex;
+};
+const diffRootNode = (oldNode, newNode, patches) => {
+  const nodePatches = compareNodes(oldNode.node, newNode.node);
+  if (nodePatches === null) {
+    replaceTree(newNode, patches);
+    return;
+  }
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (oldNode.children.length > 0 || newNode.children.length > 0) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+};
+const diffChildren = (oldChildren, newChildren, patches) => {
+  const maxLength = Math.max(oldChildren.length, newChildren.length);
+  let currentChildIndex = -1;
+  const indicesToRemove = [];
+  for (let i = 0; i < maxLength; i++) {
+    const oldNode = oldChildren[i];
+    const newNode = newChildren[i];
+    if (!oldNode && !newNode) {
+      continue;
+    }
+    if (!oldNode) {
+      currentChildIndex = navigateToParent(patches, currentChildIndex);
+      addTree(newNode, patches);
+      continue;
+    }
+    if (!newNode) {
+      indicesToRemove.push(i);
+      continue;
+    }
+    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, i);
+  }
+  navigateToParent(patches, currentChildIndex);
+  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
+    patches.push({
+      type: RemoveChild,
+      index: indicesToRemove[j]
+    });
+  }
+};
+const diffTrees = (oldTree, newTree, patches, path) => {
+  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
+    diffRootNode(oldTree[0], newTree[0], patches);
+    return;
+  }
+  diffChildren(oldTree, newTree, patches);
+};
+
+const removeTrailingNavigationPatches = patches => {
+  while (patches.length > 0) {
+    const patch = patches.at(-1);
+    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling && patch.type !== MultiNavigation) {
+      break;
+    }
+    patches.pop();
+  }
+  return patches;
+};
+
+const diffTree = (oldNodes, newNodes) => {
+  // Step 1: Convert flat arrays to tree structures
+  const oldTree = arrayToTree(oldNodes);
+  const newTree = arrayToTree(newNodes);
+  // Step 3: Compare the trees
+  const patches = [];
+  diffTrees(oldTree, newTree, patches, []);
+  // Remove trailing navigation patches since they serve no purpose
+  return removeTrailingNavigationPatches(patches);
+};
+
 const HandleBlur = 1;
 const HandleClickButton = 2;
 const HandleClickClose = 3;
@@ -2832,7 +3175,7 @@ const getFindWidgetButtons = (findButtonsEnabled, replaceButtonsEnabled, matchCa
     disabled: !replaceButtonsEnabled,
     icon: Replace,
     label: replace(),
-    name: Replace$2,
+    name: Replace$3,
     onClick: HandleClickButton
   }, {
     disabled: !replaceButtonsEnabled,
@@ -2858,18 +3201,6 @@ const getFindWidgetButtonsEnabled = (matchCount, value) => {
   };
 };
 
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
-};
-
-const text = data => {
-  return {
-    childCount: 0,
-    text: data,
-    type: Text
-  };
-};
-
 const FindWidget = 'FindWidget';
 const FindWidgetFind = 'FindWidgetFind';
 const FindWidgetMatchCount = 'FindWidgetMatchCount';
@@ -3103,20 +3434,20 @@ const getMatchCountText = (matchIndex, matchCount) => {
   return matchOf(matchIndex + 1, matchCount);
 };
 
-const renderContent = (oldState, newState) => {
+const getDom = state => {
   const {
     focus,
     inputErrorMessage,
     matchCase,
     matchCount,
+    matchIndex,
     matchWholeWord,
     preserveCase,
     replaceExpanded,
-    uid,
     useRegularExpression,
     value
-  } = newState;
-  const matchCountText = inputErrorMessage || getMatchCountText(newState.matchIndex, newState.matchCount);
+  } = state;
+  const matchCountText = inputErrorMessage || getMatchCountText(matchIndex, matchCount);
   const {
     findButtonsEnabled,
     replaceButtonsEnabled
@@ -3131,7 +3462,18 @@ const renderContent = (oldState, newState) => {
   const inputFocused = focus === FocusSearchInput;
   const replaceInputFocused = focus === FocusSearchReplaceInput;
   const dom = getFindWidgetVirtualDom(matchCountText, replaceExpanded, findButtons, findFieldButtons, replaceButtons, replaceFieldButtons, matchCount, value, hasError, inputFocused, replaceInputFocused);
-  return [SetDom2, uid, dom];
+  return dom;
+};
+const renderContent = (oldState, newState) => {
+  const {
+    uid
+  } = newState;
+  const dom = getDom(newState);
+  if (oldState.version === 0) {
+    return [SetDom2, uid, dom];
+  }
+  const oldDom = getDom(oldState);
+  return [SetPatches, uid, diffTree(oldDom, dom)];
 };
 
 const renderCss = (oldState, newState) => {
@@ -3239,7 +3581,7 @@ const getFocusSelector = focusKey => {
     case FocusFindWidgetReplaceAllButton$1:
       return ReplaceAll$2;
     case FocusFindWidgetReplaceButton$1:
-      return Replace$2;
+      return Replace$3;
     case FocusSearchInput:
       return SearchValue;
     case FocusSearchMatchCase:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/find-widget-worker",
-  "version": "3.18.0",
+  "version": "3.20.0",
   "description": "Web Worker for the find widget in Lvce Editor",
   "repository": {
     "type": "git",