@lvce-editor/static-server 0.91.29 → 0.91.30

package/static/{48f00bb → 3fd4359}/packages/renderer-worker/dist/rendererWorkerMain.js

@@ -526,7 +526,7 @@ class VError extends Error {
   }
 }
 
-const state$F = {
+const state$G = {
   commands: Object.create(null),
   pendingModules: Object.create(null),
   async load(moduleId) {
@@ -549,20 +549,20 @@ const initializeModule = module => {
 };
 const loadModule$4 = async moduleId => {
   try {
-    const module = await state$F.load(moduleId);
+    const module = await state$G.load(moduleId);
     initializeModule(module);
   } catch (error) {
     throw new VError(error, `failed to load module ${moduleId}`);
   }
 };
 const getOrLoadModule = moduleId => {
-  if (!state$F.pendingModules[moduleId]) {
-    state$F.pendingModules[moduleId] = loadModule$4(moduleId);
+  if (!state$G.pendingModules[moduleId]) {
+    state$G.pendingModules[moduleId] = loadModule$4(moduleId);
   }
-  return state$F.pendingModules[moduleId];
+  return state$G.pendingModules[moduleId];
 };
 const loadCommand = async command => {
-  if (command in state$F.commands) {
+  if (command in state$G.commands) {
     return;
   }
   await getOrLoadModule(getModuleId$2(command));
@@ -571,12 +571,12 @@ const register$2 = (commandId, listener) => {
   if (commandId.split('.').length >= 3) {
     debugger;
   }
-  state$F.commands[commandId] = listener;
+  state$G.commands[commandId] = listener;
 };
 const hasThrown = new Set();
 const execute$4 = (command, ...args) => {
-  if (command in state$F.commands) {
-    const fn = state$F.commands[command];
+  if (command in state$G.commands) {
+    const fn = state$G.commands[command];
     if (typeof fn !== 'function') {
       throw new TypeError(`[renderer-worker] Command ${command} is not a function`);
     }
@@ -585,7 +585,7 @@ const execute$4 = (command, ...args) => {
   return loadCommand(command)
   // TODO can skip then block in prod (only to prevent endless loop in dev)
   .then(() => {
-    if (!(command in state$F.commands)) {
+    if (!(command in state$G.commands)) {
       if (hasThrown.has(command)) {
         return;
       }
@@ -596,20 +596,20 @@ const execute$4 = (command, ...args) => {
   });
 };
 const setLoad = load => {
-  state$F.load = load;
+  state$G.load = load;
 };
 
-const state$E = {
+const state$F = {
   pending: Object.create(null)
 };
 const get$i = id => {
-  return state$E.pending[id];
+  return state$F.pending[id];
 };
 const has$2 = id => {
-  return id in state$E.pending;
+  return id in state$F.pending;
 };
 const set$h = (id, value) => {
-  state$E.pending[id] = value;
+  state$F.pending[id] = value;
 };
 
 const Web$1 = 1;
@@ -635,7 +635,7 @@ const getAssetDir$2 = () => {
   // @ts-ignore
   {
     // @ts-ignore
-    return '/48f00bb';
+    return '/3fd4359';
   }
 };
 const assetDir = getAssetDir$2();
@@ -1259,7 +1259,7 @@ const commandMapRef = {};
 const kDispose$1 = 'Viewlet.dispose';
 const kSetCss$1 = 'Viewlet.setCss';
 const kSetPatches$1 = 'Viewlet.setPatches';
-const state$D = {
+const state$E = {
   /** @type {Map<string | number, string>} */
   cssTexts: new Map()
 };
@@ -1269,11 +1269,11 @@ const normalizeSetCss = command => {
   if (typeof id !== 'string' && typeof id !== 'number' || typeof newText !== 'string') {
     return command;
   }
-  const oldText = state$D.cssTexts.get(id);
+  const oldText = state$E.cssTexts.get(id);
   if (oldText === newText) {
     return undefined;
   }
-  state$D.cssTexts.set(id, newText);
+  state$E.cssTexts.set(id, newText);
   return command;
 };
 const normalizeCommand = command => {
@@ -1287,7 +1287,7 @@ const normalizeCommand = command => {
     return normalizeSetCss(command);
   }
   if (command[0] === kDispose$1) {
-    state$D.cssTexts.delete(command[1]);
+    state$E.cssTexts.delete(command[1]);
   }
   return command;
 };
@@ -1302,13 +1302,13 @@ const normalizeCommands = commands => {
   return normalized;
 };
 const getCssText = id => {
-  return state$D.cssTexts.get(id);
+  return state$E.cssTexts.get(id);
 };
 const setCssText = (id, text) => {
-  state$D.cssTexts.set(id, text);
+  state$E.cssTexts.set(id, text);
 };
 const reset$3 = () => {
-  state$D.cssTexts.clear();
+  state$E.cssTexts.clear();
 };
 
 const requestAnimationFrame = fn => {
@@ -1325,7 +1325,7 @@ const kSendMultiple$1 = 'Viewlet.sendMultiple';
 const kSetCss = 'Viewlet.setCss';
 const kSetPatches = 'Viewlet.setPatches';
 const minimumFrameDuration = 16;
-const state$C = {
+const state$D = {
   frameCount: 0,
   lastFrameTime: Number.NEGATIVE_INFINITY,
   /** @type {{commands: any[], promise: Promise<any>} | undefined} */
@@ -1335,14 +1335,14 @@ const state$C = {
   tail: Promise.resolve()
 };
 const enqueue = operation => {
-  const promise = state$C.tail.then(operation);
-  state$C.tail = promise.catch(() => {});
+  const promise = state$D.tail.then(operation);
+  state$D.tail = promise.catch(() => {});
   return promise;
 };
 const waitForEligibleFrame = () => {
   return new Promise(resolve => {
     const handleFrame = timestamp => {
-      if (timestamp - state$C.lastFrameTime < minimumFrameDuration) {
+      if (timestamp - state$D.lastFrameTime < minimumFrameDuration) {
         requestAnimationFrame(handleFrame);
         return;
       }
@@ -1353,7 +1353,7 @@ const waitForEligibleFrame = () => {
 };
 const invokeWithCacheRecovery = async (method, ...params) => {
   try {
-    return await state$C.rpc.invoke(method, ...params);
+    return await state$D.rpc.invoke(method, ...params);
   } catch (error) {
     reset$3();
     throw error;
@@ -1361,22 +1361,22 @@ const invokeWithCacheRecovery = async (method, ...params) => {
 };
 const runFrame = async frame => {
   const timestamp = await waitForEligibleFrame();
-  if (state$C.pendingFrame === frame) {
-    state$C.pendingFrame = undefined;
+  if (state$D.pendingFrame === frame) {
+    state$D.pendingFrame = undefined;
   }
   const commands = normalizeCommands(frame.commands);
   if (commands.length === 0) {
     return;
   }
-  state$C.frameCount++;
+  state$D.frameCount++;
   try {
     return await invokeWithCacheRecovery(kSendMultiple$1, commands);
   } finally {
-    state$C.lastFrameTime = Math.max(timestamp, now());
+    state$D.lastFrameTime = Math.max(timestamp, now());
   }
 };
 const sealPendingFrame = () => {
-  state$C.pendingFrame = undefined;
+  state$D.pendingFrame = undefined;
 };
 const invokeDirectRendererCommand = async (method, params) => {
   const commands = normalizeCommands([[method, ...params]]);
@@ -1395,23 +1395,23 @@ const invokeCssStyleSheet = async (id, text) => {
 };
 const reset$2 = rpc => {
   reset$3();
-  state$C.frameCount = 0;
-  state$C.lastFrameTime = Number.NEGATIVE_INFINITY;
-  state$C.pendingFrame = undefined;
-  state$C.rpc = rpc;
-  state$C.tail = Promise.resolve();
+  state$D.frameCount = 0;
+  state$D.lastFrameTime = Number.NEGATIVE_INFINITY;
+  state$D.pendingFrame = undefined;
+  state$D.rpc = rpc;
+  state$D.tail = Promise.resolve();
 };
 const sendMultiple = commands => {
-  if (state$C.pendingFrame) {
-    state$C.pendingFrame.commands.push(...commands);
-    return state$C.pendingFrame.promise;
+  if (state$D.pendingFrame) {
+    state$D.pendingFrame.commands.push(...commands);
+    return state$D.pendingFrame.promise;
   }
   /** @type {{commands: any[], promise: Promise<any>}} */
   const frame = {
     commands: [...commands],
     promise: Promise.resolve()
   };
-  state$C.pendingFrame = frame;
+  state$D.pendingFrame = frame;
   frame.promise = enqueue(() => runFrame(frame));
   return frame.promise;
 };
@@ -1434,7 +1434,7 @@ const invokeAndTransfer$v = (method, ...params) => {
   sealPendingFrame();
   return enqueue(async () => {
     try {
-      return await state$C.rpc.invokeAndTransfer(method, ...params);
+      return await state$D.rpc.invokeAndTransfer(method, ...params);
     } catch (error) {
       reset$3();
       throw error;
@@ -1443,7 +1443,7 @@ const invokeAndTransfer$v = (method, ...params) => {
 };
 
 // @ts-ignore
-const state$B = {
+const state$C = {
   pendingMessages: [],
   /**
    * @type {any}
@@ -1459,9 +1459,9 @@ const getRpc$1 = async () => {
   return rpc;
 };
 const listen$1 = async () => {
-  console.assert(state$B.pendingMessages.length === 0);
+  console.assert(state$C.pendingMessages.length === 0);
   const rpc = await getRpc$1();
-  state$B.rpc = rpc;
+  state$C.rpc = rpc;
   reset$2(rpc);
 };
 const invoke$I = (method, ...params) => {
@@ -1859,18 +1859,18 @@ const create$1a = async ({
   return ipc;
 };
 
-const state$A = Object.create(null);
+const state$B = Object.create(null);
 const setAll = preferences => {
-  Object.assign(state$A, preferences);
+  Object.assign(state$B, preferences);
 };
 const get$f = key => {
-  return state$A[key];
+  return state$B[key];
 };
 const getAll$3 = () => {
-  return state$A;
+  return state$B;
 };
 const set$f = (key, value) => {
-  state$A[key] = value;
+  state$B[key] = value;
 };
 
 const getConfiguredWorkerUrl$2 = () => {
@@ -2184,32 +2184,32 @@ const canBeRestored$5 = async uri => {
 // 1. it decouples event emitter (e.g. Editor creation) from other module (Document syncing when editor was created)
 
 // TODO use normal event target
-const state$z = {
+const state$A = {
   listenerMap: Object.create(null)
 };
 const emitEvent = async (event, ...args) => {
-  const listeners = state$z.listenerMap[event] || [];
+  const listeners = state$A.listenerMap[event] || [];
   for (const listener of listeners) {
     await listener(...args);
   }
 };
 const addListener = (event, fn, options = {}) => {
-  state$z.listenerMap[event] ||= [];
-  if (state$z.listenerMap[event].includes(fn)) {
+  state$A.listenerMap[event] ||= [];
+  if (state$A.listenerMap[event].includes(fn)) {
     return;
   }
   if (options.prepend) {
-    state$z.listenerMap[event].unshift(fn);
+    state$A.listenerMap[event].unshift(fn);
   } else {
-    state$z.listenerMap[event].push(fn);
+    state$A.listenerMap[event].push(fn);
   }
 };
 
-const state$y = {
+const state$z = {
   isTest: false
 };
 const isTest = () => {
-  return state$y.isTest;
+  return state$z.isTest;
 };
 
 const stringify = value => {
@@ -2234,7 +2234,7 @@ const openUri$1 = async (path, focus = true, props = {}) => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */path, /* focus */focus, props);
 };
 
-const state$x = {
+const state$y = {
   /**
    * @type {any}
    */
@@ -2245,14 +2245,14 @@ const state$x = {
 const invoke$F = async (method, ...params) => {
   const {
     ipc
-  } = state$x;
+  } = state$y;
   const result = await invoke$H(ipc, method, ...params);
   return result;
 };
 const invokeAndTransfer$r = async (method, ...params) => {
   const {
     ipc
-  } = state$x;
+  } = state$y;
   const result = await invokeAndTransfer$t(ipc, method, ...params);
   return result;
 };
@@ -2434,7 +2434,7 @@ const setThemeColor = async themeColor => {
 // TODO by default color theme should come from local storage, session storage, cache storage, indexeddb or blob url -> fast initial load
 // actual color theme can be computed after workbench has loaded (most times will be the same and doesn't need to be computed)
 
-const state$w = {
+const state$x = {
   watchedTheme: ''
 };
 const FALLBACK_COLOR_THEME_ID = 'slime';
@@ -2445,7 +2445,7 @@ const FALLBACK_COLOR_THEME_ID = 'slime';
 const applyColorTheme = async colorThemeId => {
   try {
     string(colorThemeId);
-    state$w.colorTheme = colorThemeId;
+    state$x.colorTheme = colorThemeId;
     const colorThemeCss = await getColorThemeCss(colorThemeId);
     if (!colorThemeCss) {
       return new Error(`Color theme is empty`);
@@ -2474,10 +2474,10 @@ const setColorTheme = async colorThemeId => {
   return undefined;
 };
 const watch$2 = async id => {
-  if (state$w.watchedTheme === id) {
+  if (state$x.watchedTheme === id) {
     return;
   }
-  state$w.watchedTheme = id;
+  state$x.watchedTheme = id;
   await invoke$F('ExtensionHost.watchColorTheme', id);
 };
 const getPreferredColorTheme = () => {
@@ -2507,22 +2507,22 @@ const hydrate$b = async () => {
   await applyPreferredColorTheme();
 };
 
-const state$v = {
+const state$w = {
   href: ''
 };
 
 const initialize$2 = href => {
-  state$v.href = href;
+  state$w.href = href;
 };
 const getHref$1 = async () => {
   const href = await invoke$I(/* Location.getHref */'Location.getHref');
-  state$v.href = href;
+  state$w.href = href;
   return href;
 };
 const setPathName = async pathName => {
   const {
     href
-  } = state$v;
+  } = state$w;
   if (!href) {
     return invoke$I(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
   }
@@ -2532,7 +2532,7 @@ const setPathName = async pathName => {
     return;
   }
   await invoke$I(/* Location.setPathName */'Location.setPathName', /* pathName */pathName);
-  state$v.href = resolvedUrl.href;
+  state$w.href = resolvedUrl.href;
 };
 const hydrate$a = () => {
   return invoke$I(/* Location.hydrate */'Location.hydrate');
@@ -2557,14 +2557,14 @@ const cleanAuthCallbackUrl = async href => {
   await setPathName(url.pathname);
 };
 
-const state$u = {
+const state$v = {
   id: 0
 };
 const create$19 = () => {
-  return ++state$u.id;
+  return ++state$v.id;
 };
 
-const state$t = {
+const state$u = {
   ipc: undefined
 };
 
@@ -2573,10 +2573,10 @@ const state$t = {
  * @returns {any}
  */
 const get$c = () => {
-  return state$t.ipc;
+  return state$u.ipc;
 };
 const set$d = ipc => {
-  state$t.ipc = ipc;
+  state$u.ipc = ipc;
 };
 
 const map$3 = Object.create(null);
@@ -2629,14 +2629,14 @@ const watchFile = async (rpcId, callBackCommandId, uri) => {
   return map$3[id];
 };
 
-const state$s = {
+const state$t = {
   id: 0
 };
 const set$c = value => {
-  state$s.id = value;
+  state$t.id = value;
 };
 const get$b = () => {
-  return state$s.id;
+  return state$t.id;
 };
 
 // TODO cache window id
@@ -2812,17 +2812,65 @@ const getTestFilePath = async (platform, href) => {
 
 const testWorkerUrl = `${assetDir}/packages/test-worker/dist/testWorkerMain.js`;
 
-const launchTestWorker = async () => {
+const createTestWorker = async () => {
   const configuredWorkerUrl = getConfiguredWorkerUrl$1('develop.testWorkerPath', testWorkerUrl);
   const ipc = await create$1a({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url: configuredWorkerUrl,
-    name: 'Test Worker'
+    name: 'Test Worker',
+    url: configuredWorkerUrl
   });
   handleIpc(ipc);
   set$d(ipc);
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await invokeAndTransfer$u('TestWorkerRpc.initialize', port1);
+  await invokeAndTransfer$t(ipc, 'RendererProcess.initialize', port2);
   return ipc;
 };
+const state$s = {
+  launchPromise: undefined
+};
+const getOrCreateLaunchPromise = () => {
+  const {
+    launchPromise
+  } = state$s;
+  if (launchPromise) {
+    return launchPromise;
+  }
+  const promise = createTestWorker();
+  state$s.launchPromise = promise;
+  return promise;
+};
+const shouldPreloadTestWorker = (href, isPromptMode) => {
+  if (isPromptMode) {
+    return false;
+  }
+  const url = new URL(href);
+  return url.pathname.includes('/tests/') && !url.searchParams.has('replayId');
+};
+const preloadTestWorker = (href, isPromptMode) => {
+  if (!shouldPreloadTestWorker(href, isPromptMode)) {
+    return;
+  }
+  const promise = getOrCreateLaunchPromise();
+  void promise.catch(() => {});
+};
+const launchTestWorker = async () => {
+  const promise = getOrCreateLaunchPromise();
+  try {
+    return await promise;
+  } catch (error) {
+    const {
+      launchPromise
+    } = state$s;
+    if (launchPromise === promise) {
+      state$s.launchPromise = undefined;
+    }
+    throw error;
+  }
+};
 
 const execute$2 = async href => {
   const ipc = await launchTestWorker();
@@ -3696,7 +3744,7 @@ const getResolveRootFromSessionStorage = async () => {
 const getResolvedRootFromRendererProcess = async href => {
   const url = new URL(href);
   if (href.includes('tests/')) {
-    state$y.isTest = true;
+    state$z.isTest = true;
     return {
       path: href,
       homeDir: '',
@@ -4229,7 +4277,7 @@ const loadModule$3 = async (id, module) => {
     await (Array.isArray(module.Css) ? loadCssStyleSheets(module.Css) : loadCssStyleSheet(module.Css));
   }
   if (module.getDynamicCss) {
-    await addDynamicCss(id, module.getDynamicCss, state$A);
+    await addDynamicCss(id, module.getDynamicCss, state$B);
   }
 };
 
@@ -4746,10 +4794,12 @@ const load$4 = async (viewlet, focus = false, restore = false, restoreState = un
     if (module.renderEventListeners) {
       // TODO reuse event listeners between components
       const eventListeners = await module.renderEventListeners(newState);
-      if (shouldRenderEvents === false) {
-        commands.push(['Viewlet.registerEventListeners', viewletUid, eventListeners]);
-      } else {
-        await invoke$I('Viewlet.registerEventListeners', viewletUid, eventListeners);
+      if (eventListeners.length > 0) {
+        if (shouldRenderEvents === false) {
+          commands.push(['Viewlet.registerEventListeners', viewletUid, eventListeners]);
+        } else {
+          await invoke$I('Viewlet.registerEventListeners', viewletUid, eventListeners);
+        }
       }
     }
     if ((viewlet.visible === undefined || viewlet.visible === true) && module.show) {
@@ -6460,7 +6510,7 @@ const listen = method => {
 const launchSharedProcess = async () => {
   const ipc = await listen(Node);
   handleIpc(ipc);
-  state$x.ipc = ipc;
+  state$y.ipc = ipc;
 };
 
 const Zero = 0;
@@ -6785,8 +6835,8 @@ const exit$1 = code => {
   return invoke$F('Exit.exit', code);
 };
 
-const version = '0.91.29';
-const commit$1 = '48f00bb';
+const version = '0.91.30';
+const commit$1 = '3fd4359';
 const productNameLong$1 = 'Lvce Editor - OSS';
 const getPid = () => {
   return invoke$F('Process.getPid');
@@ -7385,7 +7435,7 @@ const getSessionContent = async () => {
 const DONT_REPLAY = new Set(['Open.openUrl', 'Download.downloadFile']);
 const replaySession = async sessionId => {
   const events = await getSessionEvents(sessionId);
-  const originalIpc = state$B.rpc.ipc;
+  const originalIpc = state$C.rpc.ipc;
   unhandleIpc(originalIpc);
   const originalSend = originalIpc.send.bind(originalIpc);
   const originalAddEventListsner = originalIpc.addEventListener.bind(originalIpc);
@@ -7400,33 +7450,33 @@ const replaySession = async sessionId => {
     } else if ('method' in data) {
       switch (data.method) {
         case 'TitleBar.handleTitleBarButtonClickClose':
-          state$B.rpc.ipc.onmessage = originalAddEventListsner;
-          state$B.rpc.ipc.send = originalSend;
+          state$C.rpc.ipc.onmessage = originalAddEventListsner;
+          state$C.rpc.ipc.send = originalSend;
           await execute$4('ElectronWindow.close');
-          state$B.rpc.ipc.onmessage = wrappedOnMessage;
-          state$B.rpc.ipc.send = wrappedSend;
+          state$C.rpc.ipc.onmessage = wrappedOnMessage;
+          state$C.rpc.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickMinimize':
-          state$B.rpc.ipc.onmessage = originalAddEventListsner;
-          state$B.rpc.ipc.send = originalSend;
+          state$C.rpc.ipc.onmessage = originalAddEventListsner;
+          state$C.rpc.ipc.send = originalSend;
           await execute$4('ElectronWindow.minimize');
-          state$B.rpc.ipc.onmessage = wrappedOnMessage;
-          state$B.rpc.ipc.send = wrappedSend;
+          state$C.rpc.ipc.onmessage = wrappedOnMessage;
+          state$C.rpc.ipc.send = wrappedSend;
           break;
         case 'TitleBar.handleTitleBarButtonClickToggleMaximize':
-          state$B.rpc.ipc.onmessage = originalAddEventListsner;
-          state$B.rpc.ipc.send = originalSend;
+          state$C.rpc.ipc.onmessage = originalAddEventListsner;
+          state$C.rpc.ipc.send = originalSend;
           await execute$4('ElectronWindow.maximize');
-          state$B.rpc.ipc.onmessage = wrappedOnMessage;
-          state$B.rpc.ipc.send = wrappedSend;
+          state$C.rpc.ipc.onmessage = wrappedOnMessage;
+          state$C.rpc.ipc.send = wrappedSend;
           break;
       }
     } else {
       throw new Error('unexpected message from renderer worker');
     }
   };
-  state$B.rpc.send = wrappedSend;
-  state$B.rpc.addEventListener('message', wrappedOnMessage);
+  state$C.rpc.send = wrappedSend;
+  state$C.rpc.addEventListener('message', wrappedOnMessage);
   const callbacks = Object.create(null);
   const invoke = event => {
     const {
@@ -7498,8 +7548,8 @@ const wrapIpc = (ipc, name, getData) => {
   return wrappedIpc;
 };
 const startRecording$1 = () => {
-  state$B.rpc.ipc = wrapIpc(state$B.rpc, 'renderer-process', event => event.data);
-  state$x.ipc = wrapIpc(state$x.ipc, 'shared-process', event => event);
+  state$C.rpc.ipc = wrapIpc(state$C.rpc, 'renderer-process', event => event.data);
+  state$y.ipc = wrapIpc(state$y.ipc, 'shared-process', event => event);
 };
 const openSession = async () => {
   await execute$4(/* Main.openUri */'Main.openUri', /* uri */'app://session.json');
@@ -7797,6 +7847,7 @@ const startup = async (platform, assetDir) => {
     set$f('layout.backendUrl', promptOptions.backendUrl);
   }
   mark(DidLoadPreferences);
+  preloadTestWorker(initData.Location.href, promptOptions !== undefined);
 
   // TODO only load this if session replay is enabled in preferences
   if (promptOptions === undefined && get$d('sessionReplay.enabled')) {
@@ -13955,29 +14006,11 @@ const Test_ipc = {
   name: name$1k
 };
 
-const defaultTimeout = 1000;
-const interval = 50;
-const delay = ms => {
-  return new Promise(resolve => {
-    setTimeout(resolve, ms);
-  });
-};
-const checkCondition = async (method, locator, fnName, options) => {
-  const timeout = options?.timeout ?? defaultTimeout;
-  const deadline = Date.now() + timeout;
-  while (true) {
-    const result = await invoke$I(method, locator, fnName, options);
-    if (!result?.error || Date.now() >= deadline) {
-      return result;
-    }
-    await delay(interval);
-  }
-};
 const checkSingleElementCondition = (locator, fnName, options) => {
-  return checkCondition('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
+  return invoke$I('TestFrameWork.checkSingleElementCondition', locator, fnName, options);
 };
 const checkMultiElementCondition = (locator, fnName, options) => {
-  return checkCondition('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
+  return invoke$I('TestFrameWork.checkMultiElementCondition', locator, fnName, options);
 };
 const showOverlay$1 = (...args) => {
   return invoke$I('TestFrameWork.showOverlay', ...args);
@@ -21078,7 +21111,7 @@ const ViewletKeyBindings_ipc = {
 
 const Deb = 'Deb';
 
-const commit = '48f00bb';
+const commit = '3fd4359';
 
 const getAutoUpdateType = () => {
   return invoke$F('AutoUpdater.getAutoUpdateType');
@@ -22001,7 +22034,7 @@ const loadContent$o = (state, savedState) => {
   const newState = getPoints(intermediateState, sideBarLocation);
   return newState;
 };
-const show$4 = async (state, module, currentViewletId) => {
+const show$4 = async (state, module, currentViewletId, restore) => {
   if (state.sideBarFocusMode && module !== SideBar && module !== StatusBar && module !== TitleBar) {
     return {
       newState: state,
@@ -22023,6 +22056,10 @@ const show$4 = async (state, module, currentViewletId) => {
       commands: []
     };
   }
+  const {
+    restore: defaultRestore
+  } = state;
+  const shouldRestore = restore ?? defaultRestore;
   const intermediateState = getPoints({
     ...state,
     [kVisible]: true,
@@ -22058,7 +22095,10 @@ const show$4 = async (state, module, currentViewletId) => {
     parentUid: uid,
     uid: childUid
   };
-  const commands = await load$4(viewlet, false, true, undefined);
+  const restoreState = shouldRestore ? undefined : {
+    restore: false
+  };
+  const commands = await load$4(viewlet, false, shouldRestore, restoreState);
 
   // TODO component might already be hidden again at this point
   const resizeCommands = await getResizeCommands(state, intermediateState);
@@ -22169,13 +22209,18 @@ const leaveSideBarFocusMode = async state => {
     commands: await getResizeCommands(state, newState)
   };
 };
-const showSideBar = async (state, moduleId = state.sideBarView) => {
-  const sideBarView = moduleId || state.sideBarView || Explorer$1;
+const showSideBar = async (state, moduleId, restore) => {
+  const {
+    restore: defaultRestore,
+    sideBarView: currentSideBarView
+  } = state;
+  const shouldRestore = restore ?? defaultRestore;
+  const sideBarView = moduleId || currentSideBarView || Explorer$1;
   if (state.sideBarVisible) {
     const switchResult = state.sideBarView === sideBarView ? {
       newState: state,
       commands: []
-    } : await callGlobalEvent(state, 'handleSideBarViewletChange', sideBarView);
+    } : await callGlobalEvent(state, 'handleSideBarViewletChange', sideBarView, shouldRestore);
     const newState = {
       ...switchResult.newState,
       sideBarView,
@@ -22194,7 +22239,7 @@ const showSideBar = async (state, moduleId = state.sideBarView) => {
   const {
     newState,
     commands
-  } = await show$4(sideBarState, SideBar, sideBarView);
+  } = await show$4(sideBarState, SideBar, sideBarView, shouldRestore);
   const activityBarCommands = await renderSideBarActivityBarCommands(newState.activityBarId, sideBarView, true);
   return {
     newState: {
@@ -22582,7 +22627,11 @@ const createPanelViewlet = async (state, viewletModuleId, editorUid, tabId, acti
   }
   const eventsIndex = commands.findIndex(command => command[0] === 'Viewlet.registerEventListeners');
   const events = eventsIndex === -1 ? [] : commands[eventsIndex][2];
-  commands.push(['Viewlet.createFunctionalRoot', viewletModuleId, actionsUid, true], ['Viewlet.registerEventListeners', actionsUid, events], ['Viewlet.setDom2', actionsUid, actionsDom], ['Viewlet.setUid', actionsUid, editorUid]);
+  commands.push(['Viewlet.createFunctionalRoot', viewletModuleId, actionsUid, true]);
+  if (events.length > 0) {
+    commands.push(['Viewlet.registerEventListeners', actionsUid, events]);
+  }
+  commands.push(['Viewlet.setDom2', actionsUid, actionsDom], ['Viewlet.setUid', actionsUid, editorUid]);
   return {
     newState: state,
     commands
@@ -23562,7 +23611,7 @@ const reset = async state => {
     await execute$4('Layout.moveSideBarRight');
   }
   if (!state.sideBarVisible || state.sideBarView !== Explorer$1) {
-    await execute$4('Layout.showSideBar', Explorer$1);
+    await execute$4('Layout.showSideBar', Explorer$1, false);
   }
   const panelViewNeedsReset = state.panelView !== Problems;
   if (state.panelVisible || panelViewNeedsReset) {
@@ -27394,7 +27443,7 @@ const handleSideBarViewletChange = async (state, moduleId, restore = true) => {
     currentViewletId
   } = state;
   const requestId = state.currentViewletRequestId + 1;
-  const savePromise = saveViewletState(currentViewletId);
+  const savePromise = restore ? saveViewletState(currentViewletId) : undefined;
   state.currentViewletRequestId = requestId;
   state.currentViewletId = moduleId;
   const uid = state.uid;
@@ -27455,7 +27504,11 @@ const handleSideBarViewletChange = async (state, moduleId, restore = true) => {
     if (titleAreaHeight > 0 && actionsDom.length > 0) {
       const events = eventsIndex >= 0 ? commands[eventsIndex][2] : [];
       actionsUid = create$19();
-      commands.push(['Viewlet.createFunctionalRoot', moduleId, actionsUid, true], ['Viewlet.registerEventListeners', actionsUid, events], ['Viewlet.setDom2', actionsUid, actionsDom], ['Viewlet.setUid', actionsUid, childUid]);
+      commands.push(['Viewlet.createFunctionalRoot', moduleId, actionsUid, true]);
+      if (events.length > 0) {
+        commands.push(['Viewlet.registerEventListeners', actionsUid, events]);
+      }
+      commands.push(['Viewlet.setDom2', actionsUid, actionsDom], ['Viewlet.setUid', actionsUid, childUid]);
     }
     if (state.currentViewletRequestId !== requestId || state.currentViewletId !== moduleId) {
       disposeFunctional(childUid);