@lvce-editor/static-server 0.106.2 → 0.106.4

package/static/{cca55a3 → 71bebb6}/extensions/builtin.video-preview/dist/videoPreviewMain.js

@@ -965,6 +965,34 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
+const createSharedLazyRpc = factory => {
+  let rpcPromise;
+  const getOrCreate = () => {
+    if (!rpcPromise) {
+      rpcPromise = factory();
+    }
+    return rpcPromise;
+  };
+  return {
+    async dispose() {
+      const rpc = await getOrCreate();
+      await rpc.dispose();
+    },
+    async invoke(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await getOrCreate();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    async send(method, ...params) {
+      const rpc = await getOrCreate();
+      rpc.send(method, ...params);
+    }
+  };
+};
+
 const create$4 = async ({
   commandMap,
   isMessagePortOpen = true,
@@ -1000,34 +1028,6 @@ const create$3 = async ({
   });
 };
 
-const createSharedLazyRpc = factory => {
-  let rpcPromise;
-  const getOrCreate = () => {
-    if (!rpcPromise) {
-      rpcPromise = factory();
-    }
-    return rpcPromise;
-  };
-  return {
-    async dispose() {
-      const rpc = await getOrCreate();
-      await rpc.dispose();
-    },
-    async invoke(method, ...params) {
-      const rpc = await getOrCreate();
-      return rpc.invoke(method, ...params);
-    },
-    async invokeAndTransfer(method, ...params) {
-      const rpc = await getOrCreate();
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    async send(method, ...params) {
-      const rpc = await getOrCreate();
-      rpc.send(method, ...params);
-    }
-  };
-};
-
 const create$2 = async ({
   commandMap,
   isMessagePortOpen,
@@ -1303,25 +1303,25 @@ const {
   set
 } = create(FileSystemWorker);
 
-const getStatusBarItems = () => {
+const getStatusBarItems$1 = () => {
   return [];
 };
-const commandMap$3 = {
-  'ExtensionApi.getStatusBarItems': getStatusBarItems
+const commandMap$4 = {
+  'ExtensionApi.getStatusBarItems': getStatusBarItems$1
 };
 
-const commandMap$2 = Object.create(null);
+const commandMap$3 = Object.create(null);
 const getCommandMap$2 = () => {
-  return commandMap$2;
+  return commandMap$3;
 };
 const registerCommandMap = newCommandMap => {
-  Object.assign(commandMap$2, newCommandMap);
+  Object.assign(commandMap$3, newCommandMap);
   register(newCommandMap);
 };
 
 const getCommandMap$1 = () => {
   return {
-    ...commandMap$3,
+    ...commandMap$4,
     ...getCommandMap$2(),
     async initialize(type, port) {
       if (type !== 'message-port') {
@@ -1341,7 +1341,7 @@ const handleExtensionManagementMessagePort = async port => {
 
 const getCommandMap = () => {
   return {
-    ...commandMap$3,
+    ...commandMap$4,
     ...getCommandMap$2(),
     'HandleMessagePort.handleExtensionManagementMessagePort': handleExtensionManagementMessagePort,
     async initialize(type, port) {
@@ -1479,7 +1479,7 @@ const registerCommand = command => {
     },
     id: command.id
   };
-  registerCommandMap(commandMap$1);
+  registerCommandMap(commandMap$2);
   return {
     dispose() {
       delete commands[command.id];
@@ -1500,11 +1500,105 @@ const executeCommand = async (id, ...args) => {
   }
   return command.execute(...args);
 };
-const commandMap$1 = {
+const commandMap$2 = {
   'ExtensionApi.executeCommand': executeCommand,
   'ExtensionApi.getCommandRegistrySnapshot': getCommandRegistrySnapshot
 };
 
+const getProviderMethod = (provider, methodName) => {
+  const method = provider[methodName];
+  if (typeof method !== 'function') {
+    return undefined;
+  }
+  return method;
+};
+const assertProviderMethod = (provider, providerName, providerId, methodName) => {
+  if (typeof provider[methodName] !== 'function') {
+    throw new ExtensionApiError(`${providerName} ${providerId} is missing ${methodName} function`);
+  }
+};
+const assertOptionalProviderMethod = (provider, providerName, providerId, methodName) => {
+  if (provider[methodName] !== undefined && typeof provider[methodName] !== 'function') {
+    throw new ExtensionApiError(`${providerName} ${providerId} has invalid ${methodName} function`);
+  }
+};
+const createProviderRegistry = ({
+  mapProvider,
+  optionalMethods = [],
+  providerName,
+  requiredMethods,
+  requireLanguageId = false
+}) => {
+  const providers = Object.create(null);
+  const hasProvider = id => {
+    return id in providers;
+  };
+  const registerProvider = provider => {
+    if (!provider) {
+      throw new ExtensionApiError(`${providerName} is not defined`);
+    }
+    const providerRecord = provider;
+    const {
+      id
+    } = providerRecord;
+    if (typeof id !== 'string' || id.length === 0) {
+      throw new ExtensionApiError(`${providerName} is missing id`);
+    }
+    if (requireLanguageId && (typeof providerRecord.languageId !== 'string' || providerRecord.languageId.length === 0)) {
+      throw new ExtensionApiError(`${providerName} ${id} is missing languageId`);
+    }
+    for (const methodName of requiredMethods) {
+      assertProviderMethod(providerRecord, providerName, id, methodName);
+    }
+    for (const methodName of optionalMethods) {
+      assertOptionalProviderMethod(providerRecord, providerName, id, methodName);
+    }
+    if (hasProvider(id)) {
+      throw new ExtensionApiError(`${providerName} ${id} is already registered`);
+    }
+    const registeredProvider = mapProvider(provider);
+    providers[registeredProvider.id] = registeredProvider;
+    return registeredProvider;
+  };
+  const deleteProvider = id => {
+    delete providers[id];
+  };
+  const getProviders = () => {
+    return Object.values(providers);
+  };
+  const getProviderByLanguageId = languageId => {
+    return getProviders().find(provider => {
+      return 'languageId' in provider && provider.languageId === languageId;
+    });
+  };
+  const reset = () => {
+    for (const id of Object.keys(providers)) {
+      delete providers[id];
+    }
+  };
+  const executeProviderByLanguageId = async (languageId, methodName, args, validateResult) => {
+    const provider = getProviderByLanguageId(languageId);
+    if (!provider) {
+      throw new ExtensionApiError(`No ${providerName} found for ${languageId}`);
+    }
+    const method = getProviderMethod(provider, methodName);
+    if (!method) {
+      throw new ExtensionApiError(`${providerName} ${provider.id} is missing ${methodName} function`);
+    }
+    const result = await method(...args);
+    return validateResult ? validateResult(result) : result;
+  };
+  return {
+    deleteProvider,
+    executeProviderByLanguageId,
+    getProviderByLanguageId,
+    getProviders,
+    hasProvider,
+    registerProvider,
+    reset
+  };
+};
+
 const getPlatform = async () => {
   const platform = await executeCommand$1('Layout.getPlatform');
   switch (platform) {
@@ -1521,6 +1615,10 @@ const getPlatform = async () => {
   }
 };
 
+const MemfsPrefix = 'memfs://';
+const isMemory = uri => {
+  return uri.startsWith(MemfsPrefix);
+};
 const isHttp = uri => {
   return uri.startsWith('http://') || uri.startsWith('https://');
 };
@@ -1533,6 +1631,9 @@ const getObjectUrl = async uri => {
   if (isHttp(uri)) {
     return uri;
   }
+  if (isMemory(uri)) {
+    return await executeCommand$1('Blob.getSrc', uri);
+  }
   const platform = await getPlatform();
   if (platform === 'web') {
     return await executeCommand$1('Blob.getSrc', uri);
@@ -1559,6 +1660,63 @@ const readAsObjectUrl = async uri => {
   }
 };
 
+const text = data => {
+  return {
+    childCount: 0,
+    text: data,
+    type: Text
+  };
+};
+
+const validVirtualDomElementTypes = new Set(Object.values(VirtualDomElements));
+const isObject = value => {
+  return typeof value === 'object' && value !== null;
+};
+const isValidNode = node => {
+  if (!isObject(node)) {
+    return false;
+  }
+  const {
+    type,
+    childCount
+  } = node;
+  return typeof type === 'number' && Number.isSafeInteger(type) && validVirtualDomElementTypes.has(type) && typeof childCount === 'number' && Number.isSafeInteger(childCount) && childCount >= 0;
+};
+const getNodeSize = (nodes, index) => {
+  const node = nodes[index];
+  let nextIndex = index + 1;
+  for (let i = 0; i < node.childCount; i++) {
+    if (nextIndex >= nodes.length) {
+      return -1;
+    }
+    const childSize = getNodeSize(nodes, nextIndex);
+    if (childSize === -1) {
+      return -1;
+    }
+    nextIndex += childSize;
+  }
+  return nextIndex - index;
+};
+const validate = nodes => {
+  if (!Array.isArray(nodes)) {
+    return false;
+  }
+  for (const node of nodes) {
+    if (!isValidNode(node)) {
+      return false;
+    }
+  }
+  let index = 0;
+  while (index < nodes.length) {
+    const nodeSize = getNodeSize(nodes, index);
+    if (nodeSize === -1) {
+      return false;
+    }
+    index += nodeSize;
+  }
+  return true;
+};
+
 const SetText = 1;
 const Replace = 2;
 const SetAttribute = 3;
@@ -1637,14 +1795,11 @@ const compareNodes = (oldNode, newNode) => {
   }
   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;
+  if (oldNode.type === Reference && oldNode.uid !== newNode.uid) {
+    patches.push({
+      type: SetReferenceNodeUid,
+      uid: newNode.uid
+    });
   }
   // Handle text nodes
   if (oldNode.type === Text && newNode.type === Text) {
@@ -1657,8 +1812,8 @@ const compareNodes = (oldNode, newNode) => {
     return patches;
   }
   // Compare attributes
-  const oldKeys = getKeys(oldNode);
-  const newKeys = getKeys(newNode);
+  const oldKeys = getKeys(oldNode).filter(key => oldNode.type !== Reference || key !== 'uid');
+  const newKeys = getKeys(newNode).filter(key => newNode.type !== Reference || key !== 'uid');
   // Check for attribute changes
   for (const key of newKeys) {
     if (oldNode[key] !== newNode[key]) {
@@ -1682,9 +1837,14 @@ const compareNodes = (oldNode, newNode) => {
 };
 
 const treeToArray = node => {
-  const result = [node.node];
-  for (const child of node.children) {
-    result.push(...treeToArray(child));
+  const result = [];
+  const stack = [node];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    result.push(current.node);
+    for (let i = current.children.length - 1; i >= 0; i--) {
+      stack.push(current.children[i]);
+    }
   }
   return result;
 };
@@ -1796,17 +1956,14 @@ const diffTrees = (oldTree, newTree, patches, path) => {
 };
 
 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];
+  while (patches.length > 0) {
+    const patch = patches.at(-1);
     if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling) {
-      lastNonNavigationIndex = i;
       break;
     }
+    patches.pop();
   }
-  // Return patches up to and including the last non-navigation patch
-  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 1);
+  return patches;
 };
 
 const diffTree = (oldNodes, newNodes) => {
@@ -1820,6 +1977,215 @@ const diffTree = (oldNodes, newNodes) => {
   return removeTrailingNavigationPatches(patches);
 };
 
+const notifyStatusBarChange = async id => {
+  await invoke('StatusBar.handleChange', id);
+};
+
+const registry = createProviderRegistry({
+  mapProvider(provider) {
+    return {
+      getStatusBarItem() {
+        return provider.getStatusBarItem();
+      },
+      id: provider.id
+    };
+  },
+  providerName: 'status bar item provider',
+  requiredMethods: ['getStatusBarItem']
+});
+const getStatusBarItem = provider => {
+  return provider.getStatusBarItem();
+};
+const isStatusBarItem = item => {
+  return item !== undefined;
+};
+const registerStatusBarItemProvider = provider => {
+  const registeredProvider = registry.registerProvider(provider);
+  registerCommandMap(commandMap$1);
+  void notifyStatusBarChange(registeredProvider.id);
+  return {
+    async dispose() {
+      registry.deleteProvider(registeredProvider.id);
+      await notifyStatusBarChange(registeredProvider.id);
+    },
+    async refresh() {
+      await notifyStatusBarChange(registeredProvider.id);
+    }
+  };
+};
+const getStatusBarItems = () => {
+  return registry.getProviders().map(getStatusBarItem).filter(isStatusBarItem);
+};
+const commandMap$1 = {
+  'ExtensionApi.getStatusBarItems': getStatusBarItems
+};
+
+const activeUidByViewId = Object.create(null);
+const explicitActiveStateByUid = Object.create(null);
+const handlesByViewId = Object.create(null);
+const itemsByUid = Object.create(null);
+const renderedUidsByViewId = Object.create(null);
+const viewIdByUid = Object.create(null);
+const stringProperties = ['ariaLabel', 'icon', 'name', 'onClick', 'text', 'title'];
+const normalizeStatusBarItem = (item, index) => {
+  if (!item || typeof item !== 'object' || Array.isArray(item)) {
+    throw new ExtensionApiError(`view status bar item ${index} must be an object`);
+  }
+  const statusBarItem = item;
+  for (const property of stringProperties) {
+    if (statusBarItem[property] !== undefined && typeof statusBarItem[property] !== 'string') {
+      throw new ExtensionApiError(`view status bar item ${index} has invalid ${property}`);
+    }
+  }
+  if (statusBarItem.spinning !== undefined && typeof statusBarItem.spinning !== 'boolean') {
+    throw new ExtensionApiError(`view status bar item ${index} has invalid spinning`);
+  }
+  return {
+    ...(statusBarItem.ariaLabel !== undefined && {
+      ariaLabel: statusBarItem.ariaLabel
+    }),
+    ...(statusBarItem.icon !== undefined && {
+      icon: statusBarItem.icon
+    }),
+    ...(statusBarItem.name !== undefined && {
+      name: statusBarItem.name
+    }),
+    ...(statusBarItem.onClick !== undefined && {
+      onClick: statusBarItem.onClick
+    }),
+    ...(statusBarItem.spinning !== undefined && {
+      spinning: statusBarItem.spinning
+    }),
+    ...(statusBarItem.text !== undefined && {
+      text: statusBarItem.text
+    }),
+    ...(statusBarItem.title !== undefined && {
+      title: statusBarItem.title
+    })
+  };
+};
+const normalizeStatusBarItems = items => {
+  if (!Array.isArray(items)) {
+    throw new ExtensionApiError('view renderStatusBarItems result must be an array');
+  }
+  return items.map(normalizeStatusBarItem);
+};
+const areItemsEqual = (oldItems, newItems) => {
+  if (oldItems.length !== newItems.length) {
+    return false;
+  }
+  return oldItems.every((oldItem, index) => {
+    const newItem = newItems[index];
+    return oldItem.ariaLabel === newItem.ariaLabel && oldItem.icon === newItem.icon && oldItem.name === newItem.name && oldItem.onClick === newItem.onClick && oldItem.spinning === newItem.spinning && oldItem.text === newItem.text && oldItem.title === newItem.title;
+  });
+};
+const disposeHandles = async viewId => {
+  const handles = handlesByViewId[viewId] || [];
+  delete handlesByViewId[viewId];
+  await Promise.all(handles.map(handle => handle.dispose()));
+};
+const replaceItems = async (viewId, itemCount) => {
+  await disposeHandles(viewId);
+  handlesByViewId[viewId] = Array.from({
+    length: itemCount
+  }, (_item, index) => registerStatusBarItemProvider({
+    getStatusBarItem() {
+      return itemsByUid[activeUidByViewId[viewId]]?.[index];
+    },
+    id: `view:${viewId}:${index}`
+  }));
+};
+const refreshItems = async viewId => {
+  await Promise.all((handlesByViewId[viewId] || []).map(handle => handle.refresh()));
+};
+const setActiveUid = (viewId, uid) => {
+  const renderedUids = renderedUidsByViewId[viewId] || [];
+  const index = renderedUids.indexOf(uid);
+  if (index !== -1) {
+    renderedUids.splice(index, 1);
+  }
+  renderedUids.push(uid);
+  renderedUidsByViewId[viewId] = renderedUids;
+  activeUidByViewId[viewId] = uid;
+};
+const renderViewStatusBarItems = async (uid, viewId, instance) => {
+  if (typeof instance.renderStatusBarItems !== 'function') {
+    return;
+  }
+  const items = normalizeStatusBarItems(await instance.renderStatusBarItems());
+  const oldItems = itemsByUid[uid] || [];
+  const wasActive = activeUidByViewId[viewId] === uid;
+  itemsByUid[uid] = items;
+  viewIdByUid[uid] = viewId;
+  if (explicitActiveStateByUid[uid] !== undefined && !explicitActiveStateByUid[uid]) {
+    return;
+  }
+  setActiveUid(viewId, uid);
+  if (wasActive && areItemsEqual(oldItems, items)) {
+    return;
+  }
+  if ((handlesByViewId[viewId]?.length || 0) !== items.length) {
+    await replaceItems(viewId, items.length);
+    return;
+  }
+  await refreshItems(viewId);
+};
+const setViewInstanceActive$1 = async (uid, active) => {
+  const viewId = viewIdByUid[uid];
+  if (!viewId) {
+    return;
+  }
+  explicitActiveStateByUid[uid] = active;
+  if (!active) {
+    if (activeUidByViewId[viewId] !== uid) {
+      return;
+    }
+    delete activeUidByViewId[viewId];
+    await disposeHandles(viewId);
+    return;
+  }
+  const wasActive = activeUidByViewId[viewId] === uid;
+  const items = itemsByUid[uid] || [];
+  setActiveUid(viewId, uid);
+  if (wasActive && (handlesByViewId[viewId]?.length || 0) === items.length) {
+    return;
+  }
+  if ((handlesByViewId[viewId]?.length || 0) !== items.length) {
+    await replaceItems(viewId, items.length);
+    return;
+  }
+  await refreshItems(viewId);
+};
+const disposeViewStatusBarItems = async uid => {
+  const viewId = viewIdByUid[uid];
+  if (!viewId) {
+    return;
+  }
+  delete itemsByUid[uid];
+  delete explicitActiveStateByUid[uid];
+  delete viewIdByUid[uid];
+  const renderedUids = renderedUidsByViewId[viewId] || [];
+  const remainingUids = renderedUids.filter(renderedUid => renderedUid !== uid);
+  if (remainingUids.length === 0) {
+    delete activeUidByViewId[viewId];
+    delete renderedUidsByViewId[viewId];
+    await disposeHandles(viewId);
+    return;
+  }
+  renderedUidsByViewId[viewId] = remainingUids;
+  if (activeUidByViewId[viewId] !== uid) {
+    return;
+  }
+  const activeUid = remainingUids.at(-1);
+  const items = itemsByUid[activeUid] || [];
+  activeUidByViewId[viewId] = activeUid;
+  if ((handlesByViewId[viewId]?.length || 0) !== items.length) {
+    await replaceItems(viewId, items.length);
+    return;
+  }
+  await refreshItems(viewId);
+};
+
 const views = Object.create(null);
 const instances = Object.create(null);
 const instanceUidsByView = Object.create(null);
@@ -2009,11 +2375,14 @@ const getVirtualDomInstance = uid => {
   }
   return instance;
 };
-const renderDom = async instance => {
+const renderDom = async (viewId, instance) => {
   const dom = await instance.render();
   if (!Array.isArray(dom)) {
     throw new ExtensionApiError('view render result must be an array');
   }
+  if (!validate(dom)) {
+    throw new ExtensionApiError(`view ${viewId} render result must be valid virtual dom`);
+  }
   return dom;
 };
 const normalizeMenuEntry = (entry, index) => {
@@ -2102,7 +2471,7 @@ const normalizeViewScrollPosition = scrollPosition => {
 };
 const renderPatches = async (uid, instance) => {
   const oldDom = renderedDoms[uid] || [];
-  const newDom = await renderDom(instance);
+  const newDom = await renderDom(contextViewIds[uid], instance);
   renderedDoms[uid] = newDom;
   const patches = diffTree(oldDom, newDom);
   return {
@@ -2237,12 +2606,14 @@ const withScrollPosition = async (result, instance) => {
     scrollPosition
   };
 };
-const withRenderMetadata = async (result, instance, contextChange) => {
+const withRenderMetadata = async (uid, viewId, result, instance, contextChange) => {
   const resultWithCss = await withCss(result, instance);
   const resultWithFocus = await withFocusSelector(resultWithCss, instance, contextChange);
   const resultWithSelections = await withSelections(resultWithFocus, instance);
   const resultWithScrollPosition = await withScrollPosition(resultWithSelections, instance);
-  return withTitle(resultWithScrollPosition, instance);
+  const resultWithTitle = await withTitle(resultWithScrollPosition, instance);
+  await renderViewStatusBarItems(uid, viewId, instance);
+  return resultWithTitle;
 };
 const maybeClearContext = async (uid, viewId) => {
   if (!contexts[uid]) {
@@ -2279,14 +2650,14 @@ const createViewInstance = async (viewId, uid, context) => {
   instanceUids.add(uid);
   instanceUidsByView[viewId] = instanceUids;
   contextViewIds[uid] = viewId;
-  const dom = await renderDom(instance);
+  const dom = await renderDom(viewId, instance);
   renderedDoms[uid] = dom;
   const result = {
     dom,
     type: 'setDom'
   };
   const contextChange = await maybeNotifyContextChanged(uid, viewId, instance);
-  return withRenderMetadata(result, instance, contextChange);
+  return withRenderMetadata(uid, viewId, result, instance, contextChange);
 };
 const dispatchViewEvent = async (uid, event) => {
   const instance = getVirtualDomInstance(uid);
@@ -2304,29 +2675,43 @@ const dispatchViewEvent = async (uid, event) => {
   }
   const result = await renderPatches(uid, instance);
   const contextChange = await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
-  return withRenderMetadata(result, instance, contextChange);
+  return withRenderMetadata(uid, contextViewIds[uid], result, instance, contextChange);
 };
 const renderViewInstance = async uid => {
   const instance = getVirtualDomInstance(uid);
   const result = await renderPatches(uid, instance);
   const contextChange = await maybeNotifyContextChanged(uid, contextViewIds[uid], instance);
-  return withRenderMetadata(result, instance, contextChange);
+  return withRenderMetadata(uid, contextViewIds[uid], result, instance, contextChange);
+};
+const setViewInstanceActive = async (uid, active) => {
+  getVirtualDomInstance(uid);
+  if (typeof active !== 'boolean') {
+    throw new ExtensionApiError('view instance active state must be a boolean');
+  }
+  await setViewInstanceActive$1(uid, active);
 };
 const disposeViewInstance = async uid => {
   const instance = instances[uid];
-  if (instance && typeof instance.dispose === 'function') {
-    await instance.dispose();
-  }
-  await maybeClearContext(uid, contextViewIds[uid]);
   const viewId = contextViewIds[uid];
-  const instanceUids = instanceUidsByView[viewId];
-  instanceUids?.delete(uid);
-  if (instanceUids?.size === 0) {
-    delete instanceUidsByView[viewId];
+  try {
+    if (instance && typeof instance.dispose === 'function') {
+      await instance.dispose();
+    }
+  } finally {
+    await disposeViewStatusBarItems(uid);
+    try {
+      await maybeClearContext(uid, viewId);
+    } finally {
+      const instanceUids = instanceUidsByView[viewId];
+      instanceUids?.delete(uid);
+      if (instanceUids?.size === 0) {
+        delete instanceUidsByView[viewId];
+      }
+      delete instances[uid];
+      delete renderedDoms[uid];
+      delete contextViewIds[uid];
+    }
   }
-  delete instances[uid];
-  delete renderedDoms[uid];
-  delete contextViewIds[uid];
 };
 const saveViewInstanceState = async uid => {
   const instance = getVirtualDomInstance(uid);
@@ -2376,7 +2761,8 @@ const commandMap = {
   'ExtensionApi.getViewMenuEntries': getViewMenuEntries,
   'ExtensionApi.getViewRegistrySnapshot': getViewRegistrySnapshot,
   'ExtensionApi.renderViewInstance': renderViewInstance,
-  'ExtensionApi.saveViewInstanceState': saveViewInstanceState
+  'ExtensionApi.saveViewInstanceState': saveViewInstanceState,
+  'ExtensionApi.setViewInstanceActive': setViewInstanceActive
 };
 
 const MediaErrorSrcNotSupported = 4;
@@ -2393,16 +2779,6 @@ const getVideoUrl = async (uri, read = readAsObjectUrl) => {
   return result.wasFound ? result.objectUrl : '';
 };
 
-const text = data => {
-  return {
-    childCount: 0,
-    text: data,
-    type: Text
-  };
-};
-
-new Set(Object.values(VirtualDomElements));
-
 const HandleError = 'handleVideoError';
 
 const parentNode = {
@@ -2514,4 +2890,3 @@ const deactivate = () => {};
 await activate();
 
 export { activate, deactivate };
-//# sourceMappingURL=videoPreviewMain.js.map