@lvce-editor/renderer-process 30.60.0 → 30.60.2

package/dist/rendererProcessMain.js

@@ -1556,7 +1556,7 @@ const launchRendererWorker = async () => {
 };
 
 const selector = 'script.RendererWorkerTrace';
-const state$h = {
+const state$i = {
   enabled: false,
   entries: []
 };
@@ -1606,14 +1606,14 @@ const isCommand = value => {
 };
 const initialize = search => {
   const searchParams = new URLSearchParams(search);
-  state$h.enabled = searchParams.has('traceRendererWorker');
-  state$h.entries = [];
+  state$i.enabled = searchParams.has('traceRendererWorker');
+  state$i.entries = [];
 };
 const record = (direction, method, params) => {
-  if (!state$h.enabled) {
+  if (!state$i.enabled) {
     return;
   }
-  state$h.entries.push({
+  state$i.entries.push({
     direction,
     method,
     params: serialize(params),
@@ -1621,7 +1621,7 @@ const record = (direction, method, params) => {
   });
 };
 const listen$1 = rpc => {
-  if (!state$h.enabled) {
+  if (!state$i.enabled) {
     return;
   }
   const ipc = rpc.ipc;
@@ -1636,7 +1636,7 @@ const listen$1 = rpc => {
   });
 };
 const exportToDom = () => {
-  if (!state$h.enabled) {
+  if (!state$i.enabled) {
     return;
   }
   const existing = document.querySelector(selector);
@@ -1644,7 +1644,7 @@ const exportToDom = () => {
   script.className = 'RendererWorkerTrace';
   script.type = 'application/json';
   script.textContent = JSON.stringify({
-    entries: state$h.entries,
+    entries: state$i.entries,
     version: 1
   });
   if (!existing) {
@@ -1652,42 +1652,42 @@ const exportToDom = () => {
   }
 };
 const scheduleExport = () => {
-  if (!state$h.enabled) {
+  if (!state$i.enabled) {
     return;
   }
   queueMicrotask(exportToDom);
 };
 
-const state$g = {
+const state$h = {
   rpc: undefined
 };
 const hydrate$4 = async () => {
   const result = await launchRendererWorker();
   if (isError(result)) {
-    state$g.rpc = undefined;
+    state$h.rpc = undefined;
     return result;
   }
-  state$g.rpc = result.value;
+  state$h.rpc = result.value;
   listen$1(result.value);
   return success(undefined);
 };
 const send$1 = (method, ...params) => {
   record('sent', method, params);
   // @ts-ignore
-  state$g.rpc.send(method, ...params);
+  state$h.rpc.send(method, ...params);
 };
 const invoke$1 = (method, ...params) => {
   record('sent', method, params);
   // @ts-ignore
-  return state$g.rpc.invoke(method, ...params);
+  return state$h.rpc.invoke(method, ...params);
 };
 const invokeAndTransfer = (method, ...params) => {
   record('sent', method, params);
   // @ts-ignore
-  return state$g.rpc.invokeAndTransfer(method, ...params);
+  return state$h.rpc.invokeAndTransfer(method, ...params);
 };
 
-const state$f = {
+const state$g = {
   client: undefined,
   enabled: false,
   lastError: '',
@@ -1697,38 +1697,38 @@ const state$f = {
 const workerUrl = new URL('sessionReplayWorkerMain.js', import.meta.url);
 const reloadMessage = 'Reload the window to start session replay with the complete DOM command history';
 const report = error => {
-  state$f.lastError = error instanceof Error ? error.message : String(error);
-  state$f.stopObserving?.();
-  state$f.stopObserving = undefined;
-  console.warn(`Session replay: ${state$f.lastError}`);
+  state$g.lastError = error instanceof Error ? error.message : String(error);
+  state$g.stopObserving?.();
+  state$g.stopObserving = undefined;
+  console.warn(`Session replay: ${state$g.lastError}`);
 };
 
 // Retain snapshot recording for older renderer workers during dependency rollout.
 const configure = async options => {
-  state$f.stopObserving?.();
-  state$f.stopObserving = undefined;
-  state$f.enabled = false;
-  if (state$f.client) {
+  state$g.stopObserving?.();
+  state$g.stopObserving = undefined;
+  state$g.enabled = false;
+  if (state$g.client) {
     try {
-      await state$f.client.invoke('stop');
+      await state$g.client.invoke('stop');
     } catch (error) {
       report(error);
     }
     // Live channels still need their proxy after capture stops.
-    if (!state$f.proxy) {
-      state$f.client.dispose();
-      state$f.client = undefined;
+    if (!state$g.proxy) {
+      state$g.client.dispose();
+      state$g.client = undefined;
     }
   }
   if (!options.local && !options.upload) return '';
-  if (state$f.proxy) throw new Error(reloadMessage);
-  state$f.lastError = '';
+  if (state$g.proxy) throw new Error(reloadMessage);
+  state$g.lastError = '';
   const client = createClient(workerUrl);
   try {
     const id = await client.invoke('start', options);
-    state$f.stopObserving = observe(document, (type, data) => client.invoke('record', type, data), report);
-    state$f.client = client;
-    state$f.enabled = true;
+    state$g.stopObserving = observe(document, (type, data) => client.invoke('record', type, data), report);
+    state$g.client = client;
+    state$g.enabled = true;
     return id;
   } catch (error) {
     client.dispose();
@@ -1736,7 +1736,7 @@ const configure = async options => {
   }
 };
 const configureProxy = async (options, port) => {
-  if (state$f.client || !options.local && !options.upload) {
+  if (state$g.client || !options.local && !options.upload) {
     port.close();
     throw new Error(reloadMessage);
   }
@@ -1749,25 +1749,25 @@ const configureProxy = async (options, port) => {
       commandMap: commandMapRef,
       messagePort: proxyPort
     });
-    const original = state$g.rpc;
-    state$g.rpc = {
+    const original = state$h.rpc;
+    state$h.rpc = {
       ...rpc,
       async dispose() {
         try {
           await rpc.dispose();
         } finally {
           client.dispose();
-          state$f.client = undefined;
-          state$f.enabled = false;
-          state$f.proxy = false;
+          state$g.client = undefined;
+          state$g.enabled = false;
+          state$g.proxy = false;
           await original?.dispose();
         }
       }
     };
-    state$f.client = client;
-    state$f.enabled = true;
-    state$f.proxy = true;
-    state$f.lastError = '';
+    state$g.client = client;
+    state$g.enabled = true;
+    state$g.proxy = true;
+    state$g.lastError = '';
     return id;
   } catch (error) {
     proxyPort?.close();
@@ -1777,21 +1777,21 @@ const configureProxy = async (options, port) => {
   }
 };
 const getSession = async () => {
-  if (!state$f.enabled || !state$f.client) throw new Error('Session replay is disabled in settings');
-  return state$f.client.invoke('export');
+  if (!state$g.enabled || !state$g.client) throw new Error('Session replay is disabled in settings');
+  return state$g.client.invoke('export');
 };
 const getStatus = async () => {
-  if (!state$f.client) return {
+  if (!state$g.client) return {
     enabled: false,
-    error: state$f.lastError
+    error: state$g.lastError
   };
   return {
-    enabled: state$f.enabled,
-    ...(await state$f.client.invoke('status')),
-    captureError: state$f.lastError
+    enabled: state$g.enabled,
+    ...(await state$g.client.invoke('status')),
+    captureError: state$g.lastError
   };
 };
-const flush = async () => state$f.client?.invoke('flush');
+const flush = async () => state$g.client?.invoke('flush');
 const openLocalFile = async () => {
   const input = document.createElement('input');
   input.type = 'file';
@@ -1911,25 +1911,25 @@ const confirm = message => {
   return window.confirm(message);
 };
 
-const state$e = {
+const state$f = {
   styleSheets: Object.create(null),
   texts: Object.create(null)
 };
 const set$b = (id, sheet) => {
-  state$e.styleSheets[id] = sheet;
+  state$f.styleSheets[id] = sheet;
 };
 const get$a = id => {
-  return state$e.styleSheets[id];
+  return state$f.styleSheets[id];
 };
 const setText$2 = (id, text) => {
-  state$e.texts[id] = text;
+  state$f.texts[id] = text;
 };
 const getText = id => {
-  return state$e.texts[id];
+  return state$f.texts[id];
 };
 const remove$4 = id => {
-  delete state$e.styleSheets[id];
-  delete state$e.texts[id];
+  delete state$f.styleSheets[id];
+  delete state$f.texts[id];
 };
 
 const addCssStyleSheet = (id, text) => {
@@ -2124,7 +2124,7 @@ const createIdGenerator = () => {
 };
 const create$A = createIdGenerator();
 
-const state$d = Object.create(null);
+const state$e = Object.create(null);
 const retainString = (item, index) => {
   const value = new Promise(resolve => {
     item.getAsString(resolve);
@@ -2175,25 +2175,25 @@ const retainItems = dataTransfer => {
 };
 const addItems = items => {
   const id = create$A();
-  state$d[id] = items;
+  state$e[id] = items;
   return id;
 };
 const add$2 = dataTransfer => {
   return addItems(retainItems(dataTransfer));
 };
 const acquire$2 = id => {
-  const items = state$d[id];
+  const items = state$e[id];
   if (!items) {
     throw new Error(`Drop data not found: ${id}`);
   }
-  delete state$d[id];
+  delete state$e[id];
   return items;
 };
 
-const state$c = Object.create(null);
+const state$d = Object.create(null);
 const acquire$1 = id => {
-  const promise = state$c[id];
-  delete state$c[id];
+  const promise = state$d[id];
+  delete state$d[id];
   return promise;
 };
 const getFileHandles = async ids => {
@@ -2203,7 +2203,7 @@ const getFileHandles = async ids => {
 };
 const add$1 = promise => {
   const id = create$A();
-  state$c[id] = promise;
+  state$d[id] = promise;
   return id;
 };
 const addFileHandle$1 = fileHandle => {
@@ -2394,14 +2394,14 @@ const getEventListenerArgs = (params, event) => {
   return serialized;
 };
 
-const state$b = {
+const state$c = {
   ipc: undefined
 };
 const getIpc = () => {
-  return state$b.ipc;
+  return state$c.ipc;
 };
 const setIpc = value => {
-  state$b.ipc = value;
+  state$c.ipc = value;
 };
 
 const nameAnonymousFunction$1 = (fn, name) => {
@@ -3324,6 +3324,10 @@ const removeProp = ($Element, key) => {
     $Element.style[key] = '';
     return;
   }
+  if (key === 'playsInline') {
+    // Firefox does not reflect playsInline as an HTMLVideoElement property.
+    $Element[key] = false;
+  }
   const attributeName = removedAttributeProps.get(key) || key;
   $Element.removeAttribute(attributeName);
 };
@@ -3372,6 +3376,10 @@ const setHtmlProp = ($Element, key, value) => {
     }
     return;
   }
+  if (key === 'autocorrect' || key === 'autocapitalize') {
+    $Element.setAttribute(key, String(value));
+    return;
+  }
   if (key === 'inputType') {
     // @ts-ignore
     $Element.type = value;
@@ -3468,12 +3476,12 @@ const render$1 = (element, eventMap, newEventMap) => {
   }
 };
 
-const renderInternal = ($Parent, elements, eventMap, newEventMap) => {
+const renderInternal = ($Parent, elements, eventMap, newEventMap, renderElement = render$1) => {
   const max = elements.length - 1;
   let stack = [];
   for (let i = max; i >= 0; i--) {
     const element = elements[i];
-    const $Element = render$1(element, eventMap, newEventMap);
+    const $Element = renderElement(element, eventMap, newEventMap);
     if (element.childCount > 0) {
       // @ts-expect-error
       $Element.append(...stack.slice(0, element.childCount));
@@ -3775,7 +3783,10 @@ const restoreFocusedElement = ($Hidden, $New, focused) => {
 const renderWithUid = ($Viewlet, dom, eventMap, uid, inputMap, focused, activeElement) => {
   const newEventMap = getEventListenerMap(uid);
   const $New = render(dom, eventMap, newEventMap).firstChild;
-  const $Hidden = createHiddenContainer($New.contains(activeElement || null) ? undefined : activeElement, focused);
+  // A referenced pane can be temporarily absent from the new layout. Leave its
+  // focused input in that pane unless there is a replacement to transfer it to.
+  const hasReplacement = focused && $New.querySelector(`[name="${CSS.escape(focused)}"]`);
+  const $Hidden = createHiddenContainer(hasReplacement && !$New.contains(activeElement || null) ? activeElement : undefined, focused);
   setComponentUid($New, uid);
   const $$NewInputs = queryInputs($New);
   for (const $Input of $$NewInputs) {
@@ -3920,26 +3931,26 @@ const launchDragAndDropWorker = async () => {
   }
 };
 
-const state$a = {
+const state$b = {
   rpc: undefined
 };
 const hydrate$3 = async () => {
   const result = await launchDragAndDropWorker();
   if (isError(result)) {
-    state$a.rpc = undefined;
+    state$b.rpc = undefined;
     return result;
   }
-  state$a.rpc = result.value;
+  state$b.rpc = result.value;
   return success(undefined);
 };
 const handleMessagePort$1 = async port => {
-  if (!state$a.rpc) {
+  if (!state$b.rpc) {
     const result = await hydrate$3();
     if (isError(result)) {
       throw result.error;
     }
   }
-  const rpc = state$a.rpc;
+  const rpc = state$b.rpc;
   if (!rpc) {
     throw new Error('Drag And Drop Worker failed to initialize');
   }
@@ -4640,7 +4651,7 @@ const create$Button = (label, icon) => {
 };
 
 // TODO this file is not needed when all elements are position fixed
-const state$9 = {
+const state$a = {
   $Widgets: undefined,
   widgetSet: new Set()
 };
@@ -4652,20 +4663,20 @@ const create$Widgets = () => {
 };
 const append$1 = $Element => {
   // TODO should not call append in the first place if it is already in DOM
-  if (state$9.widgetSet.has($Element)) {
+  if (state$a.widgetSet.has($Element)) {
     return;
   }
-  state$9.widgetSet.add($Element);
-  if (state$9.$Widgets) {
+  state$a.widgetSet.add($Element);
+  if (state$a.$Widgets) {
     // @ts-expect-error
-    state$9.$Widgets.append($Element);
+    state$a.$Widgets.append($Element);
   } else {
     // @ts-expect-error
-    state$9.$Widgets = create$Widgets();
+    state$a.$Widgets = create$Widgets();
     // @ts-expect-error
-    state$9.$Widgets.append($Element);
+    state$a.$Widgets.append($Element);
     // @ts-expect-error
-    document.body.append(state$9.$Widgets);
+    document.body.append(state$a.$Widgets);
   }
 };
 const remove$1 = $Element => {
@@ -4673,16 +4684,19 @@ const remove$1 = $Element => {
     // TODO $Element should always be defined
     return;
   }
-  state$9.widgetSet.delete($Element);
+  state$a.widgetSet.delete($Element);
   $Element.remove();
   // TODO state.$Widgets should always be defined at this point
-  if (state$9.widgetSet.size === 0 && state$9.$Widgets) {
+  if (state$a.widgetSet.size === 0 && state$a.$Widgets) {
     // @ts-expect-error
-    state$9.$Widgets.remove();
-    state$9.$Widgets = undefined;
+    state$a.$Widgets.remove();
+    state$a.$Widgets = undefined;
   }
 };
 
+const state$9 = {
+  nextNotificationId: 0
+};
 const handleCloseClick = event => {
   const $CloseButton = event.currentTarget;
   remove$1($CloseButton.parentNode);
@@ -4703,6 +4717,7 @@ const create$Notification = message => {
   const $NotificationMessage = create$NotificationMessage(message);
   const $CloseButton = create$CloseButton();
   const $Notification = document.createElement('div');
+  $Notification.id = `Notification-${++state$9.nextNotificationId}`;
   $Notification.className = 'Notification';
   $Notification.append($NotificationMessage, $CloseButton);
   return $Notification;
@@ -4716,9 +4731,10 @@ const create$s = (type, message, parentUid) => {
   if ($Parent) {
     $Notification.style.position = 'absolute';
     $Parent.append($Notification);
-    return;
+    return $Notification.id;
   }
   append$1($Notification);
+  return $Notification.id;
 };
 const findIndex$1 = $Child => {
   const $Parent = $Child.parentNode;
@@ -4750,6 +4766,7 @@ const create$NotificationWithOptions = (message, options) => {
     $NotificationOptions.append($NotificationOption);
   }
   const $Notification = document.createElement('div');
+  $Notification.id = `Notification-${++state$9.nextNotificationId}`;
   $Notification.className = 'Notification';
   $Notification.append($NotificationMessage, $CloseButton, $NotificationOptions);
   $Notification.onclick = handleNotificationClick;
@@ -4758,9 +4775,13 @@ const create$NotificationWithOptions = (message, options) => {
 const createWithOptions = (type, message, options) => {
   const $Notification = create$NotificationWithOptions(message, options);
   append$1($Notification);
+  return $Notification.id;
 };
 const dispose$h = id => {
-  // const $Notification = state.$Notifications
+  const $Notification = document.getElementById(id);
+  if ($Notification?.classList.contains('Notification')) {
+    remove$1($Notification);
+  }
 };
 
 const createObjectUrl = blob => {