@lvce-editor/extension-search-view 7.2.0 → 7.4.0

package/dist/extensionSearchViewWorkerMain.js

@@ -63,7 +63,7 @@ class AssertionError extends Error {
 const Object$1 = 1;
 const Number$1 = 2;
 const Array$1 = 3;
-const String = 4;
+const String$1 = 4;
 const Boolean$1 = 5;
 const Function = 6;
 const Null = 7;
@@ -75,7 +75,7 @@ const getType = value => {
     case 'function':
       return Function;
     case 'string':
-      return String;
+      return String$1;
     case 'object':
       if (value === null) {
         return Null;
@@ -456,7 +456,7 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1 = 3;
-const create$5 = async ({
+const create$5$1 = async ({
   isMessagePortOpen,
   messagePort
 }) => {
@@ -507,11 +507,32 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5,
+  create: create$5$1,
   signal: signal$1,
   wrap: wrap$5
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
+const commands = Object.create(null);
+const register = commandMap => {
+  Object.assign(commands, commandMap);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
 const get$2 = id => {
@@ -536,12 +557,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -697,56 +718,56 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
-const create$1$2 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two$1,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$2(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
-const create$3 = (message, result) => {
+const create$9 = (message, result) => {
   return {
-    jsonrpc: Two$1,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$3(message, resultProperty);
+  return create$9(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two$1,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -776,35 +797,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -827,36 +848,17 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-class CommandNotFoundError extends Error {
-  constructor(command) {
-    super(`Command not found ${command}`);
-    this.name = 'CommandNotFoundError';
-  }
-}
-const commands = Object.create(null);
-const register = commandMap => {
-  Object.assign(commands, commandMap);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const Two = '2.0';
-const create$s = (method, params) => {
+
+const create$8 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$r = (id, method, params) => {
+
+const create$7 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -865,15 +867,14 @@ const create$r = (id, method, params) => {
   };
   return message;
 };
+
 let id$1 = 0;
-const create$q = () => {
+const create$6 = () => {
   return ++id$1;
 };
 
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
 const registerPromise = map => {
-  const id = create$q();
+  const id = create$6();
   const {
     promise,
     resolve
@@ -885,13 +886,12 @@ const registerPromise = map => {
   };
 };
 
-// @ts-ignore
 const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
   const {
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$r(id, method, params);
+  const message = create$7(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -927,12 +927,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$s(method, params);
+      const message = create$8(method, params);
       ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket = () => {
   return false;
 };
@@ -947,6 +948,7 @@ const handleMessage = event => {
   const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -955,6 +957,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -963,7 +966,8 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$4 = async ({
+
+const create$5 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -980,7 +984,8 @@ const create$4 = async ({
   messagePort.start();
   return rpc;
 };
-const create$2$1 = async ({
+
+const create$4 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -990,17 +995,14 @@ const create$2$1 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$4({
+  return create$5({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
-const TransferMessagePortRpcParent = {
-  __proto__: null,
-  create: create$2$1
-};
-const create$1$1 = async ({
+
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1010,10 +1012,7 @@ const create$1$1 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$1$1
-};
+
 const createMockRpc = ({
   commandMap
 }) => {
@@ -1034,37 +1033,6 @@ const createMockRpc = ({
   return mockRpc;
 };
 
-const None$3 = 'none';
-
-const Button$2 = 1;
-const Div = 4;
-const Input$1 = 6;
-const Text = 12;
-const Img = 17;
-
-const Button$1 = 'event.button';
-const ClientX = 'event.clientX';
-const ClientY = 'event.clientY';
-const DeltaMode = 'event.deltaMode';
-const DeltaY = 'event.deltaY';
-const TargetValue = 'event.target.value';
-
-const Script$1 = 2;
-
-const ManageExtension = 8;
-const ExtensionSearchFilter = 95;
-
-const LeftClick = 0;
-
-const ExtensionHostWorker = 44;
-const ExtensionManagementWorker = 9006;
-const RendererWorker = 1;
-
-const FocusSelector = 'Viewlet.focusSelector';
-const SetCss = 'Viewlet.setCss';
-const SetDom2 = 'Viewlet.setDom2';
-const SetPatches = 'Viewlet.setPatches';
-
 const rpcs = Object.create(null);
 const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
@@ -1113,40 +1081,46 @@ const create$2 = rpcId => {
   };
 };
 
+const None$3 = 'none';
+
+const Button$2 = 1;
+const Div = 4;
+const Input$1 = 6;
+const Text = 12;
+const Img = 17;
+const Reference = 100;
+
+const Button$1 = 'event.button';
+const ClientX = 'event.clientX';
+const ClientY = 'event.clientY';
+const DeltaMode = 'event.deltaMode';
+const DeltaY = 'event.deltaY';
+const TargetValue = 'event.target.value';
+
+const Script$1 = 2;
+
+const ManageExtension = 8;
+const ExtensionSearchFilter = 95;
+
+const LeftClick = 0;
+
+const ExtensionHostWorker = 44;
+const ExtensionManagementWorker = 9006;
+const RendererWorker = 1;
+
+const FocusSelector = 'Viewlet.focusSelector';
+const SetCss = 'Viewlet.setCss';
+const SetDom2 = 'Viewlet.setDom2';
+const SetPatches = 'Viewlet.setPatches';
+
 const {
-  dispose: dispose$2,
   invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$1,
-  registerMockRpc,
   set: set$4
 } = create$2(ExtensionHostWorker);
-const executeReferenceProvider = async (id, offset) => {
-  // @ts-ignore
-  return invoke$2('ExtensionHostReference.executeReferenceProvider', id, offset);
-};
-const executeFileReferenceProvider = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionHostReference.executeFileReferenceProvider', id);
-};
-const getRuntimeStatus = async extensionId => {
-  // @ts-ignore
-  return invoke$2('ExtensionHost.getRuntimeStatus', extensionId);
-};
-const getEnabledOutputProviderIds = async () => {
-  const channels = await invoke$2('Output.getEnabledProviders');
-  return channels;
-};
 
 const ExtensionHost = {
   __proto__: null,
-  dispose: dispose$2,
-  executeFileReferenceProvider,
-  executeReferenceProvider,
-  getEnabledOutputProviderIds,
-  getRuntimeStatus,
   invoke: invoke$2,
-  invokeAndTransfer: invokeAndTransfer$1,
-  registerMockRpc,
   set: set$4
 };
 
@@ -1164,13 +1138,16 @@ const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(menuId);
   number(x);
   number(y);
-  // @ts-ignore
   await invoke$1('ContextMenu.show2', uid, menuId, x, y, args);
 };
 const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
+const confirm = async (message, options) => {
+  const result = await invoke$1('ConfirmPrompt.prompt', message, options);
+  return result;
+};
 const writeClipBoardText = async text => {
   await invoke$1('ClipBoard.writeText', /* text */text);
 };
@@ -1190,42 +1167,68 @@ const create$1 = () => {
   const states = Object.create(null);
   const commandMapRef = {};
   return {
-    get(uid) {
-      return states[uid];
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
     },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        oldState,
-        newState
-      };
+    diff(uid, modules, numbers) {
+      const {
+        newState,
+        oldState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
     },
     dispose(uid) {
       delete states[uid];
     },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
     getKeys() {
       return Object.keys(states).map(key => {
-        return Number.parseInt(key);
+        return Number.parseFloat(key);
       });
     },
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        newState,
+        oldState
+      };
     },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
         const {
-          oldState,
-          newState
+          newState,
+          oldState
         } = states[uid];
         const newerState = await fn(newState, ...args);
         if (oldState === newerState || newState === newerState) {
           return;
         }
-        const latest = states[uid];
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
         states[uid] = {
-          oldState: latest.oldState,
-          newState: newerState
+          newState: latestNew,
+          oldState: latestOld.oldState
         };
       };
       return wrapped;
@@ -1239,27 +1242,36 @@ const create$1 = () => {
       };
       return wrapped;
     },
-    diff(uid, modules, numbers) {
-      const {
-        oldState,
-        newState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, newState)) {
-          diffResult.push(numbers[i]);
+    wrapLoadContent(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const result = await fn(newState, ...args);
+        const {
+          error,
+          state
+        } = result;
+        if (oldState === state || newState === state) {
+          return {
+            error
+          };
         }
-      }
-      return diffResult;
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...state
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+        return {
+          error
+        };
+      };
+      return wrapped;
     }
   };
 };
@@ -1355,19 +1367,19 @@ const extensions = () => {
 const clearExtensionSearchResults = () => {
   return i18nString(ClearExtensionSearchResults);
 };
-const enable = () => {
+const enable$1 = () => {
   return i18nString(Enable);
 };
-const disable = () => {
+const disable$1 = () => {
   return i18nString(Disable);
 };
-const enableWorkspace = () => {
+const enableWorkspace$1 = () => {
   return i18nString(EnableWorkspace);
 };
-const disableWorkspace = () => {
+const disableWorkspace$1 = () => {
   return i18nString(DisableWorkspace);
 };
-const installAnotherVersion = () => {
+const installAnotherVersion$1 = () => {
   return i18nString(InstallAnotherVersion);
 };
 const copy = () => {
@@ -1511,7 +1523,7 @@ const Id = '@id';
 const Category = '@category';
 const Outdated = '@outdated';
 
-const RE_PARAM = /@\w+/g;
+const RE_PARAM = /@\w+(?::\w+)?/g;
 const deserializeCategory = value => {
   if (value.startsWith(':"') && value.endsWith('"')) {
     return value.slice(2, -1);
@@ -1550,8 +1562,17 @@ const parseValue = value => {
       builtin = true;
     }
     if (match.startsWith(Sort)) {
-      // TODO correcly parse sort order
-      sort = 'installs';
+      // Parse sort value after @sort:
+      const sortValue = match.slice(Sort.length);
+      if (sortValue.startsWith(':')) {
+        sort = sortValue.slice(1);
+      } else if (sortValue === '') {
+        // Default sort if no value specified
+        sort = 'installs';
+      } else {
+        // Handle cases like @sort:installs or @sortsize (without colon)
+        sort = sortValue.replace(/^:/, '');
+      }
     }
     if (match.startsWith(Id)) {
       // TODO improve parsing
@@ -1610,12 +1631,31 @@ const matchesParsedValue = (extension, parsedValue) => {
   return false;
 };
 
+const compareSize = (extensionA, extensionB) => {
+  // Sort by size descending (larger sizes first)
+  return extensionB.size - extensionA.size;
+};
+const compareUpdatedDate = (extensionA, extensionB) => {
+  // Sort by updated date descending (newer first)
+  return extensionB.updatedDate - extensionA.updatedDate;
+};
 const compareExtension = (extensionA, extensionB) => {
   return extensionA.name.localeCompare(extensionB.name) || extensionA.id.localeCompare(extensionB.id);
 };
 
-const sortExtensions = extensions => {
-  return extensions.toSorted(compareExtension);
+const getCompareFn = sort => {
+  if (sort === 'size') {
+    return compareSize;
+  }
+  if (sort === 'updatedDate') {
+    return compareUpdatedDate;
+  }
+  // Default to comparing by name and id
+  return compareExtension;
+};
+const sortExtensions = (extensions, parsedValue) => {
+  const compareFn = getCompareFn(parsedValue?.sort || '');
+  return extensions.toSorted(compareFn);
 };
 
 const getExtensions = async (extensions, parsedValue) => {
@@ -1625,7 +1665,7 @@ const getExtensions = async (extensions, parsedValue) => {
       filteredExtensions.push(extension);
     }
   }
-  const sortedExtensions = sortExtensions(filteredExtensions);
+  const sortedExtensions = sortExtensions(filteredExtensions, parsedValue);
   return sortedExtensions;
 };
 
@@ -1714,7 +1754,7 @@ const handleChange = async (state, update) => {
     await handleError(error);
     return {
       ...fullNewState,
-      message: `${error}`
+      message: error instanceof Error ? error.message : String(error)
     };
   }
 };
@@ -1856,7 +1896,7 @@ const create = (id, uri, x, y, width, height, platform, assetDir) => {
 };
 
 const isEqual$3 = (oldState, newState) => {
-  return newState.scrollBarHeight === newState.scrollBarHeight && oldState.scrollBarY === newState.scrollBarY && oldState.initial === newState.initial && oldState.deltaY === newState.deltaY;
+  return oldState.scrollBarHeight === newState.scrollBarHeight && oldState.scrollBarY === newState.scrollBarY && oldState.initial === newState.initial && oldState.deltaY === newState.deltaY;
 };
 
 const isEqual$2 = (oldState, newState) => {
@@ -1894,10 +1934,30 @@ const diff2 = uid => {
   return diff(uid, modules, numbers);
 };
 
+const disable = async (state, _id) => {
+  await confirm('not implemented');
+  return state;
+};
+
+const disableWorkspace = async (state, _id) => {
+  await confirm('not implemented');
+  return state;
+};
+
 const dispose = uid => {
   dispose$1(uid);
 };
 
+const enable = async (state, _id) => {
+  await confirm('not implemented');
+  return state;
+};
+
+const enableWorkspace = async (state, _id) => {
+  await confirm('not implemented');
+  return state;
+};
+
 // TODO optimize this function to return the minimum number
 // of visible items needed, e.g. when not scrolled 5 items with
 // 20px fill 100px but when scrolled 6 items are needed
@@ -2144,17 +2204,17 @@ const Separator = 1;
 const None$1 = 0;
 const SubMenu = 4;
 
-const getMenuEntries = () => {
+const getMenuEntriesList = () => {
   return [{
     command: 'SearchExtensions.enable',
     flags: None$1,
     id: 'enable',
-    label: enable()
+    label: enable$1()
   }, {
     command: 'SearchExtensions.enableWorkspace',
     flags: None$1,
     id: 'enableWorkspace',
-    label: enableWorkspace()
+    label: enableWorkspace$1()
   }, {
     command: '',
     flags: Separator,
@@ -2164,12 +2224,12 @@ const getMenuEntries = () => {
     command: 'SearchExtensions.disable',
     flags: None$1,
     id: 'disable',
-    label: disable()
+    label: disable$1()
   }, {
     command: 'SearchExtensions.disableWorkspace',
     flags: None$1,
     id: 'disableWorkspace',
-    label: disableWorkspace()
+    label: disableWorkspace$1()
   }, {
     command: '',
     flags: Separator,
@@ -2179,7 +2239,7 @@ const getMenuEntries = () => {
     command: 'SearchExtensions.installAnotherVersion',
     flags: None$1,
     id: 'installAnotherVersion',
-    label: installAnotherVersion()
+    label: installAnotherVersion$1()
   }, {
     command: 'Extensions.copyExtensionInfo',
     flags: None$1,
@@ -2280,7 +2340,7 @@ const getMenuEntries2 = (state, props) => {
     case ExtensionSearchFilter:
       return getMenuEntriesFilter();
     default:
-      return getMenuEntries();
+      return getMenuEntriesList();
   }
 };
 
@@ -2348,6 +2408,7 @@ const NavigateChild = 7;
 const NavigateParent = 8;
 const RemoveChild = 9;
 const NavigateSibling = 10;
+const SetReferenceNodeUid = 11;
 
 const isKey = key => {
   return key !== 'type' && key !== 'childCount';
@@ -2409,12 +2470,22 @@ const getChildrenWithCount = (nodes, startIndex, childCount) => {
 };
 
 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;
   }
+  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) {
@@ -2440,7 +2511,7 @@ const compareNodes = (oldNode, newNode) => {
   }
   // Check for removed attributes
   for (const key of oldKeys) {
-    if (!(key in newNode)) {
+    if (!Object.hasOwn(newNode, key)) {
       patches.push({
         type: RemoveAttribute,
         key
@@ -2458,11 +2529,78 @@ const treeToArray = node => {
   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);
-  // 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];
@@ -2471,89 +2609,17 @@ const diffChildren = (oldChildren, newChildren, patches) => {
       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
+      currentChildIndex = navigateToParent(patches, currentChildIndex);
+      addTree(newNode, patches);
+      continue;
+    }
+    if (!newNode) {
       indicesToRemove.push(i);
+      continue;
     }
+    currentChildIndex = diffExistingChild(oldNode, newNode, patches, currentChildIndex, 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
+  navigateToParent(patches, currentChildIndex);
   for (let j = indicesToRemove.length - 1; j >= 0; j--) {
     patches.push({
       type: RemoveChild,
@@ -2562,33 +2628,11 @@ const diffChildren = (oldChildren, newChildren, patches) => {
   }
 };
 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);
+    diffRootNode(oldTree[0], newTree[0], patches);
+    return;
   }
+  diffChildren(oldTree, newTree, patches);
 };
 
 const removeTrailingNavigationPatches = patches => {
@@ -2664,8 +2708,9 @@ const handleClickFilter = async state => {
     x,
     y
   } = state;
-  const menuX = x + width + 80;
-  const menuY = y + headerHeight + 100;
+  const menuX = x + width + 60;
+  const menuHeight = 370;
+  const menuY = y + headerHeight + menuHeight;
   await show2(uid, ExtensionSearchFilter, menuX, menuY, {
     menuId: ExtensionSearchFilter
   });
@@ -2865,6 +2910,33 @@ const handleScrollBarMove = (state, eventY) => {
   return setDeltaY(state, newDeltaY);
 };
 
+const handleSettingsButtonClick = async (state, index) => {
+  const {
+    deltaY,
+    headerHeight,
+    itemHeight,
+    items,
+    uid,
+    x,
+    y
+  } = state;
+  const actualIndex = index;
+  if (actualIndex < 0 || actualIndex >= items.length) {
+    return state;
+  }
+
+  // Calculate the position for the context menu
+  // The settings button is at the bottom right of the extension list item
+  const itemY = y + headerHeight + actualIndex * itemHeight - deltaY;
+  const menuX = x + 200; // Position near the right side of the extension item
+  const menuY = itemY + itemHeight - 10; // Position at the bottom of the extension item
+
+  await show2(uid, ManageExtension, menuX, menuY, {
+    menuId: ManageExtension
+  });
+  return state;
+};
+
 // TODO show error / warning  when installment fails / times out
 const handleUninstall = async (state, id) => {
   return state;
@@ -2882,7 +2954,7 @@ const sendMessagePortToExtensionHostWorker = async port => {
 
 const createExtensionHostWorkerRpc = async () => {
   try {
-    const rpc = await TransferMessagePortRpcParent.create({
+    const rpc = await create$4({
       commandMap: {},
       send: sendMessagePortToExtensionHostWorker
     });
@@ -2904,7 +2976,7 @@ const initializeExtensionHostWorker = async () => {
 
 const createExtensionManagementWorkerRpc = async () => {
   try {
-    const rpc = await TransferMessagePortRpcParent.create({
+    const rpc = await create$4({
       commandMap: {},
       send: port => sendMessagePortToExtensionManagementWorker(port, 0)
     });
@@ -2927,6 +2999,11 @@ const initialize = async () => {
   await Promise.all([initializeExtensionHostWorker(), initializeExtensionManagementWorker()]);
 };
 
+const installAnotherVersion = async state => {
+  await confirm('not implemented');
+  return state;
+};
+
 const Web = 1;
 const Electron = 2;
 const Remote = 3;
@@ -3031,6 +3108,18 @@ const getId$1 = extension => {
   }
   return extension.id;
 };
+const getSize = extension => {
+  if (!extension || extension.size === 0 || typeof extension.size !== 'number') {
+    return 0;
+  }
+  return extension.size;
+};
+const getUpdatedDate = extension => {
+  if (!extension || !extension.updatedDate || typeof extension.updatedDate !== 'number') {
+    return 0;
+  }
+  return extension.updatedDate;
+};
 const isString = item => {
   return typeof item === 'string';
 };
@@ -3056,7 +3145,7 @@ const getPublisher = extension => {
   return match[0];
 };
 
-const normalizeExtension$1 = (extension, platform, assetDir) => {
+const normalizeExtension = (extension, platform, assetDir) => {
   return {
     categories: getCategories(extension),
     description: getDescription(extension),
@@ -3064,16 +3153,14 @@ const normalizeExtension$1 = (extension, platform, assetDir) => {
     id: getId$1(extension),
     name: getName(extension),
     publisher: getPublisher(extension),
+    size: getSize(extension),
+    updatedDate: getUpdatedDate(extension),
     uri: ''
   };
 };
 
-const normalizeExtension = (extensions, platform, assetDir) => {
-  const normalized = [];
-  for (const extension of extensions) {
-    normalized.push(normalizeExtension$1(extension, platform, assetDir));
-  }
-  return normalized;
+const normalizeExtensions = (extensions, platform, assetDir) => {
+  return Array.from(extensions, extension => normalizeExtension(extension, platform, assetDir));
 };
 
 const getSavedValue = savedState => {
@@ -3111,7 +3198,7 @@ const loadContent = async (state, savedState) => {
   // TODO just get local extensions on demand (not when query string is already different)
   const allExtensions = await getAllExtensions(platform);
   const size = getViewletSize(width);
-  const normalized = normalizeExtension(allExtensions, platform, assetDir);
+  const normalized = normalizeExtensions(allExtensions, platform, assetDir);
   const updatedState = await handleInput({
     ...state,
     allExtensions: normalized,
@@ -3141,11 +3228,22 @@ const getCss = state => {
   translate: 0 ${roundedScrollBarY}px;
 }
 
-.Extensions .ListItems {
-  translate: 0 ${relative}px;
+
+/* TODO: avoid using negative margin. find a better way*/
+.ExtensionListItem:nth-child(1) {
+  margin-top: ${relative}px;
+}
 
 .ExtensionListItem {
   position: relative !important;
+  flex-shrink: 0;
+}
+
+.Extensions .ListItems {
+  display: flex;
+  flex-direction: column;
+  gap: 0;
+  overflow-y: hidden;
 }
 `;
 };
@@ -3424,9 +3522,6 @@ const getScrollBarVirtualDom = (scrollBarHeight, scrollBarTop) => {
   if (!shouldShowScrollbar) {
     return [];
   }
-  // TODO move the dynamic css into a css adopted stylesheet
-  // const heightString = Px.px(scrollBarHeight)
-  // const translateString = Px.position(0, scrollBarTop)
   return [{
     childCount: 1,
     className: mergeClassNames(ScrollBar, ScrollBarSmall),
@@ -3436,8 +3531,6 @@ const getScrollBarVirtualDom = (scrollBarHeight, scrollBarTop) => {
   }, {
     childCount: 0,
     className: ScrollBarThumb,
-    // height: heightString,
-    // translate: translateString,
     type: Div
   }];
 };
@@ -3456,6 +3549,7 @@ const getVisibleItem = (item, setSize, itemHeight, minLineY, relative, i, focuse
     focused: i === focusedIndex,
     icon,
     id,
+    index: i,
     name,
     posInSet: i + 1,
     publisher,
@@ -3713,6 +3807,7 @@ const renderEventListeners = () => {
 
 const resize = async (state, dimensions) => {
   const {
+    deltaY,
     headerHeight,
     itemHeight,
     items,
@@ -3729,14 +3824,16 @@ const resize = async (state, dimensions) => {
   const contentHeight = total * itemHeight;
   const scrollBarHeight = getScrollBarSize(height, contentHeight, minimumSliderSize);
   const numberOfVisible = getNumberOfVisibleItems$1(listHeight, itemHeight);
-  const maxLineY = Math.min(numberOfVisible, total);
+  const minLineY = Math.floor(deltaY / itemHeight);
+  const maxLineY = Math.min(minLineY + numberOfVisible, total);
   const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, total);
-  const scrollBarY = getScrollBarY$1(0, finalDeltaY, height - headerHeight, scrollBarHeight);
+  const scrollBarY = getScrollBarY$1(deltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
   return {
     ...state,
     finalDeltaY,
     height,
     maxLineY,
+    minLineY,
     scrollBarHeight,
     scrollBarY,
     width,
@@ -3780,17 +3877,19 @@ const toggleSuggest = state => {
 };
 
 const commandMap = {
+  'Extensions.copyExtensionId': wrapCommand(copyExtensionId),
+  'Extensions.copyExtensionInfo': wrapCommand(copyExtensionInfo),
   'SearchExtensions.clearSearchResults': wrapCommand(clearSearchResults),
   'SearchExtensions.closeSuggest': wrapCommand(closeSuggest),
   'SearchExtensions.copyExtensionId': wrapCommand(copyExtensionId),
   'SearchExtensions.copyExtensionInfo': wrapCommand(copyExtensionInfo),
   'SearchExtensions.create': create,
   'SearchExtensions.diff2': diff2,
-  'SearchExtensions.disable': wrapCommand(handleDisable),
-  'SearchExtensions.disableWorkspace': wrapCommand(handleDisableWorkspace),
+  'SearchExtensions.disable': wrapCommand(disable),
+  'SearchExtensions.disableWorkspace': wrapCommand(disableWorkspace),
   'SearchExtensions.dispose': dispose,
-  'SearchExtensions.enable': wrapCommand(handleEnable),
-  'SearchExtensions.enableWorkspace': wrapCommand(handleEnableWorkspace),
+  'SearchExtensions.enable': wrapCommand(enable),
+  'SearchExtensions.enableWorkspace': wrapCommand(enableWorkspace),
   'SearchExtensions.focusFirst': wrapCommand(focusFirst),
   'SearchExtensions.focusIndex': wrapCommand(focusIndex),
   'SearchExtensions.focusLast': wrapCommand(focusLast),
@@ -3801,7 +3900,7 @@ const commandMap = {
   'SearchExtensions.getActions': getActions,
   'SearchExtensions.getCommandIds': getCommandIds,
   'SearchExtensions.getKeyBindings': getKeyBindings,
-  'SearchExtensions.getMenuEntries': getMenuEntries,
+  'SearchExtensions.getMenuEntries': getMenuEntriesList,
   'SearchExtensions.getMenuEntries2': wrapGetter(getMenuEntries2),
   'SearchExtensions.getMenuEntriesFilter': getMenuEntriesFilter,
   'SearchExtensions.getMenuIds': getMenuIds,
@@ -3824,9 +3923,11 @@ const commandMap = {
   'SearchExtensions.handleScrollBarClick': wrapCommand(handleScrollBarClick),
   'SearchExtensions.handleScrollBarMove': wrapCommand(handleScrollBarMove),
   'SearchExtensions.handleScrollBarThumbPointerMove': wrapCommand(handleScrollBarMove),
+  'SearchExtensions.handleSettingsButtonClick': wrapCommand(handleSettingsButtonClick),
   'SearchExtensions.handleUninstall': wrapCommand(handleUninstall),
   'SearchExtensions.handleWheel': wrapCommand(handleWheel),
   'SearchExtensions.initialize': initialize,
+  'SearchExtensions.installAnotherVersion': wrapCommand(installAnotherVersion),
   'SearchExtensions.loadContent': wrapCommand(loadContent),
   'SearchExtensions.openSuggest': wrapCommand(openSuggest),
   'SearchExtensions.render3': render3,
@@ -3845,7 +3946,7 @@ const commandMap = {
 
 const listen = async () => {
   registerCommands(commandMap);
-  const rpc = await WebWorkerRpcClient.create({
+  const rpc = await create$3({
     commandMap: commandMap
   });
   set$2(rpc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-search-view",
-  "version": "7.2.0",
+  "version": "7.4.0",
   "description": "Extension Search View Worker",
   "repository": {
     "type": "git",