@lvce-editor/chat-view 1.7.0 → 1.8.0

package/dist/chatViewWorkerMain.js

@@ -964,32 +964,9 @@ const create$3 = async ({
   return rpc;
 };
 
-const Button$2 = 'button';
-
-const Button$1 = 1;
-const Div = 4;
-const Span = 8;
-const Text = 12;
-const P = 50;
-const TextArea = 62;
-const Reference = 100;
-
-const ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-const Key = 'event.key';
-const ShiftKey = 'event.shiftKey';
-const TargetName = 'event.target.name';
-const TargetValue = 'event.target.value';
-
 const ExtensionHostWorker = 44;
 const RendererWorker = 1;
 
-const FocusSelector = 'Viewlet.focusSelector';
-const SetCss = 'Viewlet.setCss';
-const SetDom2 = 'Viewlet.setDom2';
-const SetValueByName = 'Viewlet.setValueByName';
-const SetPatches = 'Viewlet.setPatches';
-
 const createMockRpc = ({
   commandMap
 }) => {
@@ -1302,6 +1279,7 @@ const isEqual = (oldState, newState) => {
 
 const RenderItems = 4;
 const RenderFocus = 6;
+const RenderFocusContext = 7;
 const RenderValue = 8;
 const RenderCss = 10;
 const RenderIncremental = 11;
@@ -1310,34 +1288,372 @@ const diffValue = (oldState, newState) => {
   if (oldState.composerValue === newState.composerValue) {
     return true;
   }
-  return newState.inputSource !== 'script';
+  return newState.inputSource !== 'script';
+};
+
+const modules = [isEqual, diffValue, diffFocus, isEqual$1];
+const numbers = [RenderIncremental, RenderValue, RenderFocus, RenderCss];
+
+const diff = (oldState, newState) => {
+  const diffResult = [];
+  for (let i = 0; i < modules.length; i++) {
+    const fn = modules[i];
+    if (!fn(oldState, newState)) {
+      diffResult.push(numbers[i]);
+    }
+  }
+  return diffResult;
+};
+
+const diff2 = uid => {
+  const {
+    newState,
+    oldState
+  } = get(uid);
+  const result = diff(oldState, newState);
+  return result;
+};
+
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+const Key = 'event.key';
+const ShiftKey = 'event.shiftKey';
+const TargetName = 'event.target.name';
+const TargetValue = 'event.target.value';
+
+const FocusSelector = 'Viewlet.focusSelector';
+const SetCss = 'Viewlet.setCss';
+const SetDom2 = 'Viewlet.setDom2';
+const SetFocusContext = 'Viewlet.setFocusContext';
+const SetValueByName = 'Viewlet.setValueByName';
+const SetPatches = 'Viewlet.setPatches';
+
+const FocusChatInput = 8000;
+
+const Button$2 = 'button';
+
+const Button$1 = 1;
+const Div = 4;
+const Span = 8;
+const Text = 12;
+const P = 50;
+const TextArea = 62;
+const Reference = 100;
+
+const Enter = 3;
+
+const Shift = 1 << 10 >>> 0;
+
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
+
+const text = data => {
+  return {
+    childCount: 0,
+    text: data,
+    type: Text
+  };
+};
+
+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) => {
+  const patches = [];
+  // 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;
+  }
+  // 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 (!(key in newNode)) {
+      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 diffChildren = (oldChildren, newChildren, patches) => {
+  const maxLength = Math.max(oldChildren.length, newChildren.length);
+  // Track where we are: -1 means at parent, >= 0 means at child index
+  let currentChildIndex = -1;
+  // Collect indices of children to remove (we'll add these patches at the end in reverse order)
+  const indicesToRemove = [];
+  for (let i = 0; i < maxLength; i++) {
+    const oldNode = oldChildren[i];
+    const newNode = newChildren[i];
+    if (!oldNode && !newNode) {
+      continue;
+    }
+    if (!oldNode) {
+      // Add new node - we should be at the parent
+      if (currentChildIndex >= 0) {
+        // Navigate back to parent
+        patches.push({
+          type: NavigateParent
+        });
+        currentChildIndex = -1;
+      }
+      // Flatten the entire subtree so renderInternal can handle it
+      const flatNodes = treeToArray(newNode);
+      patches.push({
+        type: Add,
+        nodes: flatNodes
+      });
+    } else if (newNode) {
+      // Compare nodes to see if we need any patches
+      const nodePatches = compareNodes(oldNode.node, newNode.node);
+      // If nodePatches is null, the node types are incompatible - need to replace
+      if (nodePatches === null) {
+        // Navigate to this child
+        if (currentChildIndex === -1) {
+          patches.push({
+            type: NavigateChild,
+            index: i
+          });
+          currentChildIndex = i;
+        } else if (currentChildIndex !== i) {
+          patches.push({
+            type: NavigateSibling,
+            index: i
+          });
+          currentChildIndex = i;
+        }
+        // Replace the entire subtree
+        const flatNodes = treeToArray(newNode);
+        patches.push({
+          type: Replace,
+          nodes: flatNodes
+        });
+        // After replace, we're at the new element (same position)
+        continue;
+      }
+      // Check if we need to recurse into children
+      const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
+      // Only navigate to this element if we need to do something
+      if (nodePatches.length > 0 || hasChildrenToCompare) {
+        // Navigate to this child if not already there
+        if (currentChildIndex === -1) {
+          patches.push({
+            type: NavigateChild,
+            index: i
+          });
+          currentChildIndex = i;
+        } else if (currentChildIndex !== i) {
+          patches.push({
+            type: NavigateSibling,
+            index: i
+          });
+          currentChildIndex = i;
+        }
+        // Apply node patches (these apply to the current element, not children)
+        if (nodePatches.length > 0) {
+          patches.push(...nodePatches);
+        }
+        // Compare children recursively
+        if (hasChildrenToCompare) {
+          diffChildren(oldNode.children, newNode.children, patches);
+        }
+      }
+    } else {
+      // Remove old node - collect the index for later removal
+      indicesToRemove.push(i);
+    }
+  }
+  // Navigate back to parent if we ended at a child
+  if (currentChildIndex >= 0) {
+    patches.push({
+      type: NavigateParent
+    });
+    currentChildIndex = -1;
+  }
+  // Add remove patches in reverse order (highest index first)
+  // This ensures indices remain valid as we remove
+  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
+    patches.push({
+      type: RemoveChild,
+      index: indicesToRemove[j]
+    });
+  }
+};
+const diffTrees = (oldTree, newTree, patches, path) => {
+  // At the root level (path.length === 0), we're already AT the element
+  // So we compare the root node directly, then compare its children
+  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
+    const oldNode = oldTree[0];
+    const newNode = newTree[0];
+    // Compare root nodes
+    const nodePatches = compareNodes(oldNode.node, newNode.node);
+    // If nodePatches is null, the root node types are incompatible - need to replace
+    if (nodePatches === null) {
+      const flatNodes = treeToArray(newNode);
+      patches.push({
+        type: Replace,
+        nodes: flatNodes
+      });
+      return;
+    }
+    if (nodePatches.length > 0) {
+      patches.push(...nodePatches);
+    }
+    // Compare children
+    if (oldNode.children.length > 0 || newNode.children.length > 0) {
+      diffChildren(oldNode.children, newNode.children, patches);
+    }
+  } else {
+    // Non-root level or multiple root elements - use the regular comparison
+    diffChildren(oldTree, newTree, patches);
+  }
 };
 
-const modules = [isEqual, diffValue, diffFocus, isEqual$1];
-const numbers = [RenderIncremental, RenderValue, RenderFocus, RenderCss];
-
-const diff = (oldState, newState) => {
-  const diffResult = [];
-  for (let i = 0; i < modules.length; i++) {
-    const fn = modules[i];
-    if (!fn(oldState, newState)) {
-      diffResult.push(numbers[i]);
+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 diffResult;
+  // Return patches up to and including the last non-navigation patch
+  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 1);
 };
 
-const diff2 = uid => {
-  const {
-    newState,
-    oldState
-  } = get(uid);
-  const result = diff(oldState, newState);
-  return result;
+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 getKeyBindings = () => {
-  return [];
+  return [{
+    command: 'Chat.handleSubmit',
+    key: Enter,
+    when: FocusChatInput
+  }, {
+    command: 'Chat.enterNewLine',
+    key: Shift | Enter,
+    when: FocusChatInput
+  }];
 };
 
 const SESSION_PREFIX$1 = 'session:';
@@ -1649,6 +1965,7 @@ const handleClickNew = async state => {
 
 const handleClickSettings = async () => {
   // TODO
+  await invoke('Main.openUri', 'app://settings.json');
 };
 
 const handleInput = async (state, value, inputSource = 'user') => {
@@ -1744,6 +2061,10 @@ const handleKeyDown = async (state, key, shiftKey) => {
   return handleSubmit(submitState);
 };
 
+const handleNewline = async state => {
+  return handleInput(state, `${state.composerValue}\n`);
+};
+
 const id = 7201;
 const sendMessagePortToExtensionHostWorker = async port => {
   await sendMessagePortToExtensionHostWorker$1(port, id);
@@ -1777,397 +2098,129 @@ const getSavedBounds = savedState => {
   const {
     height,
     width,
-    x,
-    y
-  } = savedState;
-  if (typeof x !== 'number') {
-    return undefined;
-  }
-  if (typeof y !== 'number') {
-    return undefined;
-  }
-  if (typeof width !== 'number') {
-    return undefined;
-  }
-  if (typeof height !== 'number') {
-    return undefined;
-  }
-  return {
-    height,
-    width,
-    x,
-    y
-  };
-};
-
-const getSavedSelectedSessionId = savedState => {
-  if (!isObject(savedState)) {
-    return undefined;
-  }
-  const {
-    selectedSessionId
-  } = savedState;
-  if (typeof selectedSessionId !== 'string') {
-    return undefined;
-  }
-  return selectedSessionId;
-};
-
-const getSavedSessions = savedState => {
-  if (!isObject(savedState)) {
-    return undefined;
-  }
-  const {
-    sessions
-  } = savedState;
-  if (!Array.isArray(sessions)) {
-    return undefined;
-  }
-  return sessions;
-};
-
-const loadContent = async (state, savedState) => {
-  const savedBounds = getSavedBounds(savedState);
-  const sessions = getSavedSessions(savedState) || state.sessions;
-  const preferredSessionId = getSavedSelectedSessionId(savedState) || state.selectedSessionId;
-  const selectedSessionId = sessions.some(session => session.id === preferredSessionId) ? preferredSessionId : sessions[0]?.id || '';
-  const viewMode = sessions.length === 0 ? 'list' : state.viewMode === 'detail' ? 'detail' : 'list';
-  return {
-    ...state,
-    ...savedBounds,
-    initial: false,
-    selectedSessionId,
-    sessions,
-    viewMode
-  };
-};
-
-// TODO render things like scrollbar height,scrollbar offset, textarea height,
-// list height
-const css = `
-`;
-const renderCss = (oldState, newState) => {
-  return [SetCss, newState.uid, css];
-};
-
-const getFocusSelector = focus => {
-  switch (focus) {
-    case 'composer':
-    case 'input':
-      return '[name="composer"]';
-    case 'header':
-      return '[name="create-session"]';
-    case 'list':
-      return '[name^="session:"]';
-    case 'send-button':
-      return '[name="send"]';
-    default:
-      return '[name="composer"]';
-  }
-};
-const renderFocus = (oldState, newState) => {
-  const selector = getFocusSelector(newState.focus);
-  return [FocusSelector, selector];
-};
-
-const mergeClassNames = (...classNames) => {
-  return classNames.filter(Boolean).join(' ');
-};
-
-const text = data => {
-  return {
-    childCount: 0,
-    text: data,
-    type: Text
-  };
-};
-
-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) => {
-  const patches = [];
-  // 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;
-  }
-  // 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]
-      });
-    }
+    x,
+    y
+  } = savedState;
+  if (typeof x !== 'number') {
+    return undefined;
   }
-  // Check for removed attributes
-  for (const key of oldKeys) {
-    if (!(key in newNode)) {
-      patches.push({
-        type: RemoveAttribute,
-        key
-      });
-    }
+  if (typeof y !== 'number') {
+    return undefined;
   }
-  return patches;
+  if (typeof width !== 'number') {
+    return undefined;
+  }
+  if (typeof height !== 'number') {
+    return undefined;
+  }
+  return {
+    height,
+    width,
+    x,
+    y
+  };
 };
 
-const treeToArray = node => {
-  const result = [node.node];
-  for (const child of node.children) {
-    result.push(...treeToArray(child));
+const getSavedSelectedSessionId = savedState => {
+  if (!isObject(savedState)) {
+    return undefined;
   }
-  return result;
+  const {
+    selectedSessionId
+  } = savedState;
+  if (typeof selectedSessionId !== 'string') {
+    return undefined;
+  }
+  return selectedSessionId;
 };
 
-const diffChildren = (oldChildren, newChildren, patches) => {
-  const maxLength = Math.max(oldChildren.length, newChildren.length);
-  // Track where we are: -1 means at parent, >= 0 means at child index
-  let currentChildIndex = -1;
-  // Collect indices of children to remove (we'll add these patches at the end in reverse order)
-  const indicesToRemove = [];
-  for (let i = 0; i < maxLength; i++) {
-    const oldNode = oldChildren[i];
-    const newNode = newChildren[i];
-    if (!oldNode && !newNode) {
-      continue;
-    }
-    if (!oldNode) {
-      // Add new node - we should be at the parent
-      if (currentChildIndex >= 0) {
-        // Navigate back to parent
-        patches.push({
-          type: NavigateParent
-        });
-        currentChildIndex = -1;
-      }
-      // Flatten the entire subtree so renderInternal can handle it
-      const flatNodes = treeToArray(newNode);
-      patches.push({
-        type: Add,
-        nodes: flatNodes
-      });
-    } else if (newNode) {
-      // Compare nodes to see if we need any patches
-      const nodePatches = compareNodes(oldNode.node, newNode.node);
-      // If nodePatches is null, the node types are incompatible - need to replace
-      if (nodePatches === null) {
-        // Navigate to this child
-        if (currentChildIndex === -1) {
-          patches.push({
-            type: NavigateChild,
-            index: i
-          });
-          currentChildIndex = i;
-        } else if (currentChildIndex !== i) {
-          patches.push({
-            type: NavigateSibling,
-            index: i
-          });
-          currentChildIndex = i;
-        }
-        // Replace the entire subtree
-        const flatNodes = treeToArray(newNode);
-        patches.push({
-          type: Replace,
-          nodes: flatNodes
-        });
-        // After replace, we're at the new element (same position)
-        continue;
-      }
-      // Check if we need to recurse into children
-      const hasChildrenToCompare = oldNode.children.length > 0 || newNode.children.length > 0;
-      // Only navigate to this element if we need to do something
-      if (nodePatches.length > 0 || hasChildrenToCompare) {
-        // Navigate to this child if not already there
-        if (currentChildIndex === -1) {
-          patches.push({
-            type: NavigateChild,
-            index: i
-          });
-          currentChildIndex = i;
-        } else if (currentChildIndex !== i) {
-          patches.push({
-            type: NavigateSibling,
-            index: i
-          });
-          currentChildIndex = i;
-        }
-        // Apply node patches (these apply to the current element, not children)
-        if (nodePatches.length > 0) {
-          patches.push(...nodePatches);
-        }
-        // Compare children recursively
-        if (hasChildrenToCompare) {
-          diffChildren(oldNode.children, newNode.children, patches);
-        }
-      }
-    } else {
-      // Remove old node - collect the index for later removal
-      indicesToRemove.push(i);
-    }
-  }
-  // Navigate back to parent if we ended at a child
-  if (currentChildIndex >= 0) {
-    patches.push({
-      type: NavigateParent
-    });
-    currentChildIndex = -1;
+const getSavedSessions = savedState => {
+  if (!isObject(savedState)) {
+    return undefined;
   }
-  // Add remove patches in reverse order (highest index first)
-  // This ensures indices remain valid as we remove
-  for (let j = indicesToRemove.length - 1; j >= 0; j--) {
-    patches.push({
-      type: RemoveChild,
-      index: indicesToRemove[j]
-    });
+  const {
+    sessions
+  } = savedState;
+  if (!Array.isArray(sessions)) {
+    return undefined;
   }
+  return sessions;
 };
-const diffTrees = (oldTree, newTree, patches, path) => {
-  // At the root level (path.length === 0), we're already AT the element
-  // So we compare the root node directly, then compare its children
-  if (path.length === 0 && oldTree.length === 1 && newTree.length === 1) {
-    const oldNode = oldTree[0];
-    const newNode = newTree[0];
-    // Compare root nodes
-    const nodePatches = compareNodes(oldNode.node, newNode.node);
-    // If nodePatches is null, the root node types are incompatible - need to replace
-    if (nodePatches === null) {
-      const flatNodes = treeToArray(newNode);
-      patches.push({
-        type: Replace,
-        nodes: flatNodes
-      });
-      return;
-    }
-    if (nodePatches.length > 0) {
-      patches.push(...nodePatches);
-    }
-    // Compare children
-    if (oldNode.children.length > 0 || newNode.children.length > 0) {
-      diffChildren(oldNode.children, newNode.children, patches);
-    }
-  } else {
-    // Non-root level or multiple root elements - use the regular comparison
-    diffChildren(oldTree, newTree, patches);
-  }
+
+const loadContent = async (state, savedState) => {
+  const savedBounds = getSavedBounds(savedState);
+  const sessions = getSavedSessions(savedState) || state.sessions;
+  const preferredSessionId = getSavedSelectedSessionId(savedState) || state.selectedSessionId;
+  const selectedSessionId = sessions.some(session => session.id === preferredSessionId) ? preferredSessionId : sessions[0]?.id || '';
+  const viewMode = sessions.length === 0 ? 'list' : state.viewMode === 'detail' ? 'detail' : 'list';
+  return {
+    ...state,
+    ...savedBounds,
+    initial: false,
+    selectedSessionId,
+    sessions,
+    viewMode
+  };
 };
 
-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;
+const openMockSession = (state, mockSessionId, mockChatMessages) => {
+  if (!mockSessionId) {
+    return state;
+  }
+  const existingSession = state.sessions.find(session => session.id === mockSessionId);
+  const sessions = existingSession ? state.sessions.map(session => {
+    if (session.id !== mockSessionId) {
+      return session;
     }
+    return {
+      ...session,
+      messages: mockChatMessages
+    };
+  }) : [...state.sessions, {
+    id: mockSessionId,
+    messages: mockChatMessages,
+    title: mockSessionId
+  }];
+  return {
+    ...state,
+    renamingSessionId: '',
+    selectedSessionId: mockSessionId,
+    sessions,
+    viewMode: 'detail'
+  };
+};
+
+// TODO render things like scrollbar height,scrollbar offset, textarea height,
+// list height
+const css = `
+`;
+const renderCss = (oldState, newState) => {
+  return [SetCss, newState.uid, css];
+};
+
+const getFocusSelector = focus => {
+  switch (focus) {
+    case 'composer':
+    case 'input':
+      return '[name="composer"]';
+    case 'header':
+      return '[name="create-session"]';
+    case 'list':
+      return '[name^="session:"]';
+    case 'send-button':
+      return '[name="send"]';
+    default:
+      return '[name="composer"]';
   }
-  // Return patches up to and including the last non-navigation patch
-  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 1);
+};
+const renderFocus = (oldState, newState) => {
+  const selector = getFocusSelector(newState.focus);
+  return [FocusSelector, selector];
 };
 
-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 renderFocusContext = (oldState, newState) => {
+  const when = 2344;
+  return [SetFocusContext, newState.uid, when];
 };
 
 const ChatActions = 'ChatActions';
@@ -2464,6 +2517,8 @@ const getRenderer = diffType => {
       return renderCss;
     case RenderFocus:
       return renderFocus;
+    case RenderFocusContext:
+      return renderFocusContext;
     case RenderIncremental:
       return renderIncremental;
     case RenderItems:
@@ -2538,6 +2593,10 @@ const renderEventListeners = () => {
   }];
 };
 
+const rerender = state => {
+  return structuredClone(state);
+};
+
 const reset = async state => {
   return {
     ...state,
@@ -2608,6 +2667,7 @@ const commandMap = {
   'Chat.clearInput': wrapCommand(clearInput),
   'Chat.create': create,
   'Chat.diff2': diff2,
+  'Chat.enterNewLine': wrapCommand(handleNewline),
   'Chat.getCommandIds': getCommandIds,
   'Chat.getKeyBindings': getKeyBindings,
   'Chat.handleChatListContextMenu': handleChatListContextMenu,
@@ -2625,8 +2685,10 @@ const commandMap = {
   'Chat.initialize': initialize,
   'Chat.loadContent': wrapCommand(loadContent),
   'Chat.loadContent2': wrapCommand(loadContent),
+  'Chat.openMockSession': wrapCommand(openMockSession),
   'Chat.render2': render2,
   'Chat.renderEventListeners': renderEventListeners,
+  'Chat.rerender': wrapCommand(rerender),
   'Chat.reset': wrapCommand(reset),
   'Chat.resize': wrapCommand(resize),
   'Chat.saveState': wrapGetter(saveState),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/chat-view",
-  "version": "1.7.0",
+  "version": "1.8.0",
   "description": "Chat View Worker",
   "repository": {
     "type": "git",
@@ -11,6 +11,7 @@
   "type": "module",
   "main": "dist/chatViewWorkerMain.js",
   "dependencies": {
+    "@lvce-editor/constants": "^4.1.0",
     "@lvce-editor/i18n": "^2.1.0",
     "@lvce-editor/virtual-dom-worker": "^8.9.0"
   }