@lvce-editor/process-explorer-worker 3.4.0 → 3.6.0

package/index.js

@@ -184,7 +184,7 @@ const {
   dispose: dispose$3,
   get: get$2,
   getCommandIds,
-  getKeys,
+  getKeys: getKeys$1,
   registerCommands,
   set: set$9,
   wrapCommand,
@@ -192,7 +192,14 @@ const {
   wrapLoadContent
 } = create$e();
 
-const create$d = (id, _uri, x, y, width, height, _args, parentUid, platform = 0, assetDir = '') => {
+const getIncludeFrontendMemoryUsage = args => {
+  if (!args || typeof args !== 'object') {
+    return false;
+  }
+  const createArgs = args;
+  return createArgs.includeFrontendMemoryUsage === true;
+};
+const create$d = (id, _uri, x, y, width, height, args, parentUid, platform = 0, assetDir = '') => {
   const state = {
     assetDir,
     collapsedPids: [],
@@ -203,6 +210,7 @@ const create$d = (id, _uri, x, y, width, height, _args, parentUid, platform = 0,
     focused: false,
     focusedIndex: -1,
     height,
+    includeFrontendMemoryUsage: getIncludeFrontendMemoryUsage(args),
     initial: true,
     parentUid,
     platform,
@@ -1471,6 +1479,7 @@ const Th = 13;
 const THead = 14;
 const Tr = 15;
 const Pre = 51;
+const Reference = 100;
 
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
@@ -1508,6 +1517,7 @@ const TestWorker = 9001;
 const FocusSelector = 'Viewlet.focusSelector';
 const SetDom2 = 'Viewlet.setDom2';
 const SetFocusContext = 'Viewlet.setFocusContext';
+const SetPatches = 'Viewlet.setPatches';
 
 const Empty = 0;
 const FocusExplorer = 13;
@@ -2128,15 +2138,16 @@ const isEqual$1 = (oldState, newState) => {
 };
 
 const isEqual = (oldState, newState) => {
-  return oldState.initial === newState.initial && oldState.errorCodeFrame === newState.errorCodeFrame && oldState.errorMessage === newState.errorMessage && oldState.errorStack === newState.errorStack && oldState.visibleProcesses === newState.visibleProcesses;
+  return oldState.initial === newState.initial && oldState.errorCodeFrame === newState.errorCodeFrame && oldState.errorMessage === newState.errorMessage && oldState.errorStack === newState.errorStack && oldState.focusedIndex === newState.focusedIndex && oldState.visibleProcesses === newState.visibleProcesses;
 };
 
 const RenderItems = 1;
 const RenderFocus = 2;
 const RenderFocusContext = 3;
+const RenderIncremental = 4;
 
 const modules = [isEqual, isEqual$1, isEqual$1];
-const numbers = [RenderItems, RenderFocus, RenderFocusContext];
+const numbers = [RenderIncremental, RenderFocus, RenderFocusContext];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -2170,7 +2181,7 @@ const dispose$1 = uid => {
   pending.delete(uid);
 };
 const update = async uid => {
-  if (!getKeys().includes(uid)) {
+  if (!getKeys$1().includes(uid)) {
     dispose$1(uid);
     return;
   }
@@ -2458,6 +2469,86 @@ const killProcess = async (state, index = state.focusedIndex) => {
   return state;
 };
 
+const WindowPid = -1;
+const isValidMemoryValue = value => {
+  return typeof value === 'number' && Number.isFinite(value) && value >= 0;
+};
+const getMeasureMemory = () => {
+  const {
+    measureUserAgentSpecificMemory
+  } = performance;
+  if (typeof measureUserAgentSpecificMemory !== 'function') {
+    return undefined;
+  }
+  return measureUserAgentSpecificMemory.bind(performance);
+};
+const getUrlName = url => {
+  if (!url || url === 'cross-origin-url') {
+    return url;
+  }
+  try {
+    const parsed = new URL(url);
+    const parts = parsed.pathname.split('/').filter(Boolean);
+    return parts.at(-1) || parsed.hostname || url;
+  } catch {
+    const withoutQuery = url.split(/[?#]/, 1)[0];
+    const parts = withoutQuery.split('/').filter(Boolean);
+    return parts.at(-1) || url;
+  }
+};
+const getAttributionName = attribution => {
+  const scope = attribution.scope || 'memory';
+  const url = attribution.url ? getUrlName(attribution.url) : '';
+  if (url) {
+    return `${scope}: ${url}`;
+  }
+  return scope;
+};
+const getBreakdownName = (entry, index) => {
+  if (entry.attribution && entry.attribution.length > 0) {
+    return entry.attribution.map(getAttributionName).join(', ');
+  }
+  if (entry.types && entry.types.length > 0) {
+    return entry.types.join(', ');
+  }
+  return `breakdown ${index + 1}`;
+};
+const toBreakdownProcess = (entry, index) => {
+  const name = getBreakdownName(entry, index);
+  return {
+    cmd: name,
+    memory: entry.bytes,
+    name,
+    pid: -2 - index,
+    ppid: WindowPid,
+    synthetic: true
+  };
+};
+const getFrontendMemoryUsage = async rootPid => {
+  const measureMemory = getMeasureMemory();
+  if (!measureMemory) {
+    return [];
+  }
+  try {
+    const measurement = await measureMemory();
+    if (!isValidMemoryValue(measurement.bytes)) {
+      return [];
+    }
+    const breakdown = measurement.breakdown || [];
+    const breakdownProcesses = breakdown.filter(entry => isValidMemoryValue(entry.bytes) && entry.bytes > 0).map(toBreakdownProcess);
+    return [{
+      cmd: 'window',
+      memory: measurement.bytes,
+      name: 'window',
+      pid: WindowPid,
+      ppid: rootPid,
+      synthetic: true
+    }, ...breakdownProcesses];
+  } catch {
+    return [];
+  }
+};
+
 const sendMessagePortToProcessExplorer = async port => {
   const rendererWorker = RendererWorker;
   await rendererWorker.sendMessagePortToProcessExplorer(port);
@@ -2554,7 +2645,9 @@ const refresh = async state => {
       includeElectronData
     }));
     const processes = await invoke('ListProcessesWithMemoryUsage.listProcessesWithMemoryUsage', rootPid, includeElectronData);
-    const visibleProcesses = getVisibleProcesses(processes, state.collapsedPids, rootPid);
+    const frontendMemoryProcesses = state.includeFrontendMemoryUsage ? await getFrontendMemoryUsage(rootPid) : [];
+    const allProcesses = [...processes, ...frontendMemoryProcesses];
+    const visibleProcesses = getVisibleProcesses(allProcesses, state.collapsedPids, rootPid);
     return {
       ...state,
       errorCodeFrame: '',
@@ -2562,7 +2655,7 @@ const refresh = async state => {
       errorStack: '',
       focusedIndex: getFocusedIndex(state.focusedIndex, visibleProcesses),
       initial: false,
-      processes,
+      processes: allProcesses,
       rootPid,
       visibleProcesses
     };
@@ -2612,6 +2705,267 @@ const text = data => {
   };
 };
 
+const SetText = 1;
+const Replace = 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 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 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) {
+    if (oldNode.uid !== newNode.uid) {
+      patches.push({
+        type: SetReferenceNodeUid,
+        uid: newNode.uid
+      });
+    }
+    return patches;
+  }
+  // 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);
+  const newKeys = getKeys(newNode);
+  // 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 = [node.node];
+  for (const child of node.children) {
+    result.push(...treeToArray(child));
+  }
+  return result;
+};
+
+const navigateToChild = (patches, currentChildIndex, index) => {
+  if (currentChildIndex === -1) {
+    patches.push({
+      type: NavigateChild,
+      index
+    });
+    return index;
+  }
+  if (currentChildIndex !== index) {
+    patches.push({
+      type: NavigateSibling,
+      index
+    });
+  }
+  return index;
+};
+const navigateToParent = (patches, currentChildIndex) => {
+  if (currentChildIndex >= 0) {
+    patches.push({
+      type: NavigateParent
+    });
+  }
+  return -1;
+};
+const addTree = (newNode, patches) => {
+  patches.push({
+    type: Add,
+    nodes: treeToArray(newNode)
+  });
+};
+const replaceTree = (newNode, patches) => {
+  patches.push({
+    type: Replace,
+    nodes: treeToArray(newNode)
+  });
+};
+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;
+  if (nodePatches.length === 0 && !hasChildrenToCompare) {
+    return currentChildIndex;
+  }
+  const nextChildIndex = navigateToChild(patches, currentChildIndex, index);
+  if (nodePatches.length > 0) {
+    patches.push(...nodePatches);
+  }
+  if (hasChildrenToCompare) {
+    diffChildren(oldNode.children, newNode.children, patches);
+  }
+  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 => {
+  // Find the last non-navigation patch
+  let lastNonNavigationIndex = -1;
+  for (let i = patches.length - 1; i >= 0; i--) {
+    const patch = patches[i];
+    if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling) {
+      lastNonNavigationIndex = i;
+      break;
+    }
+  }
+  // Return patches up to and including the last non-navigation patch
+  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 1);
+};
+
+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 Grid = 'grid';
 const GridCell = 'gridcell';
 const None = 'none';
@@ -2797,12 +3151,21 @@ const renderItems = (oldState, newState) => {
   return [SetDom2, newState.uid, getDom(newState)];
 };
 
+const renderIncremental = (oldState, newState) => {
+  const oldDom = renderItems(oldState, oldState)[2];
+  const newDom = renderItems(newState, newState)[2];
+  const patches = diffTree(oldDom, newDom);
+  return [SetPatches, newState.uid, patches];
+};
+
 const getRenderer = diffType => {
   switch (diffType) {
     case RenderFocus:
       return renderFocus;
     case RenderFocusContext:
       return renderFocusContext;
+    case RenderIncremental:
+      return renderIncremental;
     case RenderItems:
       return renderItems;
     default:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/process-explorer-worker",
-  "version": "3.4.0",
+  "version": "3.6.0",
   "description": "Explorer Worker",
   "repository": {
     "type": "git",