@lvce-editor/quick-pick-worker 4.30.0 → 4.32.0

package/dist/quickPickWorkerMain.js

@@ -553,7 +553,7 @@ const execute = (command, ...args) => {
 
 const Two$1 = '2.0';
 const callbacks$2 = Object.create(null);
-const get$4 = id => {
+const get$5 = id => {
   return callbacks$2[id];
 };
 const remove$2 = id => {
@@ -774,7 +774,7 @@ const warn$1 = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$4(id);
+  const fn = get$5(id);
   if (!fn) {
     console.log(response);
     warn$1(`callback ${id} may already be disposed`);
@@ -1174,10 +1174,10 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$a = (id, rpc) => {
+const set$b = (id, rpc) => {
   rpcs[id] = rpc;
 };
-const get$3 = id => {
+const get$4 = id => {
   return rpcs[id];
 };
 const remove$1 = id => {
@@ -1188,18 +1188,18 @@ const remove$1 = id => {
 const create$4 = rpcId => {
   return {
     async dispose() {
-      const rpc = get$3(rpcId);
+      const rpc = get$4(rpcId);
       await rpc.dispose();
     },
     // @ts-ignore
     invoke(method, ...params) {
-      const rpc = get$3(rpcId);
+      const rpc = get$4(rpcId);
       // @ts-ignore
       return rpc.invoke(method, ...params);
     },
     // @ts-ignore
     invokeAndTransfer(method, ...params) {
-      const rpc = get$3(rpcId);
+      const rpc = get$4(rpcId);
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
@@ -1207,7 +1207,7 @@ const create$4 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$a(rpcId, mockRpc);
+      set$b(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove$1(rpcId);
@@ -1216,7 +1216,7 @@ const create$4 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$a(rpcId, rpc);
+      set$b(rpcId, rpc);
     }
   };
 };
@@ -1243,7 +1243,7 @@ const FocusQuickPickInput = 20;
 
 const {
   invoke: invoke$8,
-  set: set$9
+  set: set$a
 } = create$4(EditorWorker);
 const getLines = async editorUid => {
   const lines = await invoke$8('Editor.getLines2', editorUid);
@@ -1252,7 +1252,7 @@ const getLines = async editorUid => {
 
 const {
   invoke: invoke$7,
-  set: set$8
+  set: set$9
 } = create$4(ExtensionManagementWorker);
 const getLanguages = (platform, assetDir) => {
   return invoke$7('Extensions.getLanguages', platform, assetDir);
@@ -1260,19 +1260,25 @@ const getLanguages = (platform, assetDir) => {
 
 const {
   invoke: invoke$6,
-  set: set$7
+  set: set$8
 } = create$4(7013);
 
 const {
   invoke: invoke$5,
-  set: set$6
+  set: set$7
 } = create$4(RendererProcess);
 
 const {
   invoke: invoke$4,
   invokeAndTransfer,
-  set: set$5
+  set: set$6
 } = create$4(RendererWorker);
+const initializeRendererWorkerForWorker = async commandMap => {
+  const rpc = await create$5({
+    commandMap
+  });
+  set$6(rpc);
+};
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
@@ -1656,10 +1662,10 @@ const create$2 = () => {
 
 const {
   dispose: dispose$1,
-  get: get$2,
+  get: get$3,
   getCommandIds,
   registerCommands,
-  set: set$4,
+  set: set$5,
   wrapAsyncCommand,
   wrapCommand
 } = create$2();
@@ -1956,7 +1962,7 @@ const create = (uid, uri, listItemHeight, x, y, width, height, platform, args, _
     platform,
     value: ''
   };
-  set$4(uid, state, state);
+  set$5(uid, state, state);
 };
 
 const isEqual$4 = (oldState, newState) => {
@@ -2007,7 +2013,7 @@ const diff2 = uid => {
   const {
     newState,
     oldState
-  } = get$2(uid);
+  } = get$3(uid);
   return diff(oldState, newState);
 };
 
@@ -2723,6 +2729,120 @@ const collectWarnings = items => {
   return warnings;
 };
 
+const state$4 = {};
+const set$4 = value => {
+  state$4.rpc = value;
+};
+const invoke$3 = (method, ...args) => {
+  if (!state$4.rpc) {
+    throw new Error('Cache worker is not initialized');
+  }
+  return state$4.rpc.invoke(method, ...args);
+};
+
+const cacheName$1 = 'quick-pick-commands-v1';
+const version = 1;
+const isJsonValue = value => {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+    return true;
+  }
+  if (typeof value === 'number') {
+    return Number.isFinite(value);
+  }
+  if (Array.isArray(value)) {
+    return value.every(isJsonValue);
+  }
+  if (typeof value !== 'object') {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return (prototype === Object.prototype || prototype === null) && Object.values(value).every(isJsonValue);
+};
+const canSerialize = value => {
+  try {
+    JSON.stringify(value);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const isCommand = value => {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const command = value;
+  if (typeof command.id !== 'string' || typeof command.label !== 'string') {
+    return false;
+  }
+  if (command.args === undefined) {
+    return true;
+  }
+  return canSerialize(command.args) && isJsonValue(command.args);
+};
+const isContribution = value => {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const contribution = value;
+  if (typeof contribution.hash !== 'string' || !/^[\da-f]{64}$/.test(contribution.hash) || !Array.isArray(contribution.commands)) {
+    return false;
+  }
+  return contribution.commands.every(isCommand);
+};
+const isCacheableCommands = commands => {
+  try {
+    return commands.every(isCommand);
+  } catch {
+    return false;
+  }
+};
+const isEntry$1 = value => {
+  if (!value || typeof value !== 'object') {
+    return false;
+  }
+  const entry = value;
+  return entry.version === version && isContribution(entry.builtin) && isContribution(entry.extensions);
+};
+const getCacheUrl = (applicationId, assetDir, platform) => {
+  const context = JSON.stringify({
+    applicationId: applicationId ?? null,
+    assetDir,
+    platform
+  });
+  return `https://quick-pick-cache.invalid/cache/v1/commands/${encodeURIComponent(context)}`;
+};
+const get$2 = async (applicationId, assetDir, platform) => {
+  try {
+    const cached = await invoke$3('Cache.getCacheStorageItem', getCacheUrl(applicationId, assetDir, platform), cacheName$1);
+    if (!cached) {
+      return undefined;
+    }
+    const expires = Date.parse(cached.headers.expires || '');
+    if (!Number.isFinite(expires) || expires <= Date.now()) {
+      return undefined;
+    }
+    const entry = JSON.parse(new TextDecoder().decode(cached.body));
+    return isEntry$1(entry) ? entry : undefined;
+  } catch {
+    return undefined;
+  }
+};
+const set$3 = async (applicationId, assetDir, platform, entry) => {
+  const expires = new Date(Date.now() + 90 * 24 * 60 * 60 * 1000).toUTCString();
+  const body = JSON.stringify(entry);
+  const headers = {
+    'cache-control': 'private, max-age=7776000',
+    'content-length': String(new TextEncoder().encode(body).byteLength),
+    'content-type': 'application/json',
+    expires
+  };
+  try {
+    await invoke$3('Cache.setCacheStorageItem', getCacheUrl(applicationId, assetDir, platform), body, cacheName$1, headers);
+  } catch {
+    // Caching is optional; storage failures must not break command selection.
+  }
+};
+
 const handleError = async (error, notify = true, prefix = '') => {
   console.error(error);
 };
@@ -2751,7 +2871,7 @@ const warn = (...args) => {
   console.warn(...args);
 };
 
-const state$4 = {
+const state$3 = {
   menuEntries: []
 };
 const getAll = async () => {
@@ -2762,22 +2882,46 @@ const getAll = async () => {
   } catch {
     // ignore
   }
-  return state$4.menuEntries;
+  return state$3.menuEntries;
 };
 const add$1 = menuEntries => {
-  state$4.menuEntries = [...state$4.menuEntries, ...menuEntries];
+  state$3.menuEntries = [...state$3.menuEntries, ...menuEntries];
 };
 
 const changeLanguageModePick = {
   id: 'QuickPick.changeLanguageMode',
   label: 'Change Language Mode'
 };
-
-// TODO combine Ajax with cache (specify strategy: cacheFirst, networkFirst)
-const getBuiltinPicks = async () => {
+const isCommandProviderResponse = value => {
+  return !!value && typeof value === 'object' && !Array.isArray(value) && 'matchesCache' in value && 'hash' in value;
+};
+const getBuiltinPicks = async ifNonMatch => {
+  const result = await invoke$4('Layout.getAllQuickPickMenuEntries', ifNonMatch);
+  if (isCommandProviderResponse(result)) {
+    const response = result;
+    return response.commands ? {
+      ...response,
+      commands: [...response.commands, changeLanguageModePick]
+    } : response;
+  }
+  return Array.isArray(result) ? [...result, changeLanguageModePick] : [...(await getAll()), changeLanguageModePick];
+};
+const getBuiltinFallback = async () => {
   const builtinPicks = await getAll();
   return [...builtinPicks, changeLanguageModePick];
 };
+const getBuiltinCommands = async (response, cached) => {
+  if (isCommandProviderResponse(response)) {
+    if (response.matchesCache) {
+      return cached?.builtin.commands ?? [];
+    }
+    return response.commands ?? getBuiltinFallback();
+  }
+  if (Array.isArray(response)) {
+    return response;
+  }
+  return getBuiltinFallback();
+};
 const prefixIdWithExt = item => {
   return {
     ...item,
@@ -2785,16 +2929,24 @@ const prefixIdWithExt = item => {
     label: item.label || item.id
   };
 };
-const getExtensionPicks = async (assetDir, platform, applicationId) => {
+const getExtensionPicks = async (assetDir, platform, applicationId, ifNonMatch) => {
   try {
-    // TODO
-    // Assert.string(assetDir)
-    // Assert.number(platform)
-    // TODO ask extension management worker directly
-    // TODO don't call this every time, cache the results
-    const extensionPicks = applicationId === undefined ? await invoke$4('ExtensionHost.getCommands', assetDir, platform) : await invoke$4('Application.execute', applicationId, 'ExtensionHost.getCommands', assetDir, platform);
+    const extensionPicks = applicationId === undefined ? await invoke$4('ExtensionHost.getCommands', assetDir, platform, undefined, ifNonMatch) : await invoke$4('Application.execute', applicationId, 'ExtensionHost.getCommands', assetDir, platform, ifNonMatch);
     if (!extensionPicks) {
-      return [];
+      return undefined;
+    }
+    if (isCommandProviderResponse(extensionPicks)) {
+      if (extensionPicks.matchesCache || !extensionPicks.commands) {
+        return extensionPicks;
+      }
+      const warnings = collectWarnings(extensionPicks.commands);
+      for (const warning of warnings) {
+        warn(`[QuickPick] ${warning}`);
+      }
+      return {
+        ...extensionPicks,
+        commands: extensionPicks.commands.map(prefixIdWithExt)
+      };
     }
     const warnings = collectWarnings(extensionPicks);
     for (const warning of warnings) {
@@ -2804,7 +2956,59 @@ const getExtensionPicks = async (assetDir, platform, applicationId) => {
     return mappedPicks;
   } catch (error) {
     console.error(`Failed to get extension picks: ${error}`);
-    return [];
+    return undefined;
+  }
+};
+const getExtensionCommands = (response, cached) => {
+  if (isCommandProviderResponse(response)) {
+    if (response.matchesCache) {
+      return cached?.extensions.commands ?? [];
+    }
+    return response.commands ?? [];
+  }
+  if (Array.isArray(response)) {
+    return response;
+  }
+  return cached?.extensions.commands ?? [];
+};
+const toCachedCommands = items => {
+  const commands = items.map(item => ({
+    ...(item.args !== undefined && {
+      args: item.args
+    }),
+    id: String(item.id),
+    label: typeof item.label === 'string' ? item.label : String(item.id)
+  }));
+  return isCacheableCommands(commands) ? commands : undefined;
+};
+const saveCommandCache = async (applicationId, assetDir, platform, cached, builtinResponse, extensionResponse, builtinPicks, extensionPicks) => {
+  const builtinCommands = toCachedCommands(builtinPicks);
+  const extensionCommands = toCachedCommands(extensionPicks);
+  if (!builtinCommands || !extensionCommands) {
+    return;
+  }
+  const builtinHash = isCommandProviderResponse(builtinResponse) ? builtinResponse.hash : cached?.builtin.hash;
+  const extensionHash = isCommandProviderResponse(extensionResponse) ? extensionResponse.hash : cached?.extensions.hash;
+  if (!builtinHash || !extensionHash) {
+    return;
+  }
+  await set$3(applicationId, assetDir, platform, {
+    builtin: {
+      commands: builtinCommands,
+      hash: builtinHash
+    },
+    extensions: {
+      commands: extensionCommands,
+      hash: extensionHash
+    },
+    version: 1
+  });
+};
+const getOptional = async callback => {
+  try {
+    return await callback();
+  } catch {
+    return undefined;
   }
 };
 const toProtoVisibleItem$3 = item => {
@@ -2829,15 +3033,25 @@ const getPicks$e = async (value, args, {
   assetDir = '',
   platform = 0
 } = {}) => {
-  // TODO get picks in parallel
-  const builtinPicks = await getBuiltinPicks();
-  const extensionPicks = await getExtensionPicks(assetDir, platform, applicationId);
+  let cacheEnabled = false;
+  try {
+    cacheEnabled = (await invoke$4('Preferences.get', 'quickPick.cache')) !== false;
+  } catch {
+    // If preferences are unavailable, preserve the existing uncached command behavior.
+  }
+  const cached = cacheEnabled ? await get$2(applicationId, assetDir, platform) : undefined;
+  const [builtinResponse, extensionResponse] = await Promise.all([getOptional(() => getBuiltinPicks(cacheEnabled ? cached?.builtin.hash ?? null : undefined)), getOptional(() => getExtensionPicks(assetDir, platform, applicationId, cacheEnabled ? cached?.extensions.hash ?? null : undefined))]);
+  const builtinPicks = await getBuiltinCommands(builtinResponse, cached);
+  const extensionPicks = getExtensionCommands(extensionResponse, cached);
+  if (cacheEnabled) {
+    await saveCommandCache(applicationId, assetDir, platform, cached, builtinResponse, extensionResponse, builtinPicks, extensionPicks);
+  }
   const allPicks = [...builtinPicks, ...extensionPicks];
   const converted = allPicks.map(toProtoVisibleItem$3);
   return value === '>' ? converted.toSorted((a, b) => a.label.localeCompare(b.label)) : converted;
 };
 
-const state$3 = {
+const state$2 = {
   args: [],
   items: Object.create(null)
 };
@@ -2847,24 +3061,24 @@ const idState = {
 };
 const add = items => {
   const nextId = ++idState.value;
-  state$3.items[nextId] = items;
+  state$2.items[nextId] = items;
   return nextId;
 };
 const get$1 = id => {
-  return state$3.items[id] || [];
+  return state$2.items[id] || [];
 };
 const remove = id => {
-  delete state$3.items[id];
+  delete state$2.items[id];
 };
 
-const state$2 = {
+const state$1 = {
   rpc: undefined
 };
-const set$3 = newRpc => {
-  state$2.rpc = newRpc;
+const set$2 = newRpc => {
+  state$1.rpc = newRpc;
 };
-const invoke$3 = (method, ...args) => {
-  return state$2.rpc.invoke(method, ...args);
+const invoke$2 = (method, ...args) => {
+  return state$1.rpc.invoke(method, ...args);
 };
 
 const isTextInput = args => {
@@ -2895,14 +3109,14 @@ const toProtoVisibleItem$2 = item => {
   };
 };
 const getPicks$d = async (searchValue, args) => {
-  state$3.args = args;
+  state$2.args = args;
   if (isTextInput(args)) {
     return [];
   }
   const options = args.at(-1);
   let items;
   if (options?.mode === 'quickInput') {
-    items = searchValue === '' && options?.customItemsId ? get$1(options.customItemsId) : await invoke$3('ExtensionHostQuickPick.renderQuickInput', options.quickInputId, searchValue);
+    items = searchValue === '' && options?.customItemsId ? get$1(options.customItemsId) : await invoke$2('ExtensionHostQuickPick.renderQuickInput', options.quickInputId, searchValue);
   } else {
     items = options?.customItemsId ? get$1(options.customItemsId) : args[1] || [];
   }
@@ -2930,20 +3144,16 @@ const getWorkspacePath = async () => {
   return invoke$4('Workspace.getUri');
 };
 
-const state$1 = {};
-const set$2 = value => {
-  state$1.rpc = value;
-};
-const invoke$2 = (method, ...args) => {
-  if (!state$1.rpc) {
-    throw new Error('Cache worker is not initialized');
-  }
-  return state$1.rpc.invoke(method, ...args);
-};
-
 const cacheName = 'quick-pick-files-v1';
+const encodePathSegment = segment => encodeURIComponent(segment).replaceAll('+', '%2B').replaceAll(/%25([\da-f]{2})/gi, '%$1');
 const cacheUrl = workspace => {
-  const path = workspace.replaceAll('\\', '/').replace(/^\/+/, '').split('/').map(encodeURIComponent).join('/');
+  const uriMatch = workspace.match(/^([a-z][\da-z+.-]*):\/\/([^/]*)(\/.*)?$/i);
+  if (uriMatch) {
+    const [, scheme, authority, uriPath = ''] = uriMatch;
+    const path = [scheme.toLowerCase(), encodePathSegment(authority), ...uriPath.split('/').filter(Boolean).map(encodePathSegment)].filter(Boolean).join('/');
+    return `https://quick-pick-cache.invalid/cache/v1/${path}`;
+  }
+  const path = workspace.replaceAll('\\', '/').replace(/^\/+/, '').split('/').filter(Boolean).map(encodePathSegment).join('/');
   return `https://quick-pick-cache.invalid/cache/v1/file/${path}`;
 };
 const isEntry = value => {
@@ -2955,7 +3165,7 @@ const isEntry = value => {
 };
 const get = async workspace => {
   try {
-    const cached = await invoke$2('Cache.getCacheStorageItem', cacheUrl(workspace), cacheName);
+    const cached = await invoke$3('Cache.getCacheStorageItem', cacheUrl(workspace), cacheName);
     if (!cached) {
       return undefined;
     }
@@ -2979,7 +3189,7 @@ const set$1 = async (workspace, entry) => {
     expires
   };
   try {
-    await invoke$2('Cache.setCacheStorageItem', cacheUrl(workspace), body, cacheName, headers);
+    await invoke$3('Cache.setCacheStorageItem', cacheUrl(workspace), body, cacheName, headers);
   } catch {
     // Caching is optional; a storage failure must not break file search.
   }
@@ -3655,7 +3865,7 @@ const getOptions = args => {
 const selectPick$a = async (_pick, value) => {
   const {
     args
-  } = state$3;
+  } = state$2;
   const options = getOptions(args);
   if (options.executeItemCommand && _pick.command) {
     return {
@@ -4364,7 +4574,7 @@ const handleMessagePort = async port => {
     isMessagePortOpen: true,
     messagePort: port
   });
-  set$3(rpc);
+  set$2(rpc);
 };
 
 const state = {
@@ -4380,7 +4590,7 @@ const invoke$1 = (method, ...params) => {
   return invoke$5(method, ...params);
 };
 const set = rpc => {
-  set$6(rpc);
+  set$7(rpc);
   state.connected = true;
 };
 
@@ -5321,11 +5531,11 @@ const render2 = (uid, diffResult) => {
   const {
     newState,
     oldState
-  } = get$2(uid);
+  } = get$3(uid);
   if (oldState === newState) {
     return [];
   }
-  set$4(uid, newState, newState);
+  set$5(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   if (!isConnected()) {
     return commands;
@@ -5529,7 +5739,7 @@ const initializeCacheWorker = async () => {
       await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToCacheWorker', port);
     }
   });
-  set$2(rpc);
+  set$4(rpc);
 };
 
 const initializeEditorWorker = async () => {
@@ -5539,7 +5749,7 @@ const initializeEditorWorker = async () => {
       await sendMessagePortToEditorWorker(port, 0);
     }
   });
-  set$9(rpc);
+  set$a(rpc);
 };
 
 const initializeExtensionManagementWorker = async () => {
@@ -5549,7 +5759,7 @@ const initializeExtensionManagementWorker = async () => {
       await sendMessagePortToExtensionManagementWorker(port, 0);
     }
   });
-  set$8(rpc);
+  set$9(rpc);
 };
 
 const initializeFileSearchWorker = async () => {
@@ -5559,20 +5769,13 @@ const initializeFileSearchWorker = async () => {
       await sendMessagePortToFileSearchWorker2(port, 0);
     }
   });
-  set$7(rpc);
-};
-
-const initializeRendererWorker = async () => {
-  const rpc = await create$5({
-    commandMap: commandMap
-  });
-  set$5(rpc);
+  set$8(rpc);
 };
 
 const listen = async () => {
   Object.assign(commandMapRef, commandMap);
   registerCommands(commandMap);
-  await Promise.all([initializeRendererWorker(), initializeEditorWorker(), initializeExtensionManagementWorker(), initializeFileSearchWorker(), initializeCacheWorker()]);
+  await Promise.all([initializeRendererWorkerForWorker(commandMap), initializeEditorWorker(), initializeExtensionManagementWorker(), initializeFileSearchWorker(), initializeCacheWorker()]);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/quick-pick-worker",
-  "version": "4.30.0",
+  "version": "4.32.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/lvce-editor/quick-pick-worker.git"