@lvce-editor/renderer-process 30.60.1 → 30.60.3

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) => {
@@ -3931,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');
   }
@@ -4651,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()
 };
@@ -4663,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 => {
@@ -4684,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);
@@ -4714,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;
@@ -4727,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;
@@ -4761,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;
@@ -4769,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 => {
@@ -10797,7 +10807,13 @@ const handleFullScreenChange = isFullScreen => {
   send$1('Layout.handleFullScreenChange', isFullScreen);
 };
 const handleDocumentFullScreenChange = () => {
-  handleFullScreenChange(Boolean(document.fullscreenElement));
+  const {
+    fullscreenElement
+  } = document;
+  if (fullscreenElement && fullscreenElement !== document.documentElement) {
+    return;
+  }
+  handleFullScreenChange(Boolean(fullscreenElement));
 };
 const sendVisibilityChangeHint = () => {
   send$1(/* SaveState.handleVisibilityChange */'SaveState.handleVisibilityChange', /* visibilityState */'hidden');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/renderer-process",
-  "version": "30.60.1",
+  "version": "30.60.3",
   "keywords": [
     "lvce-editor",
     "renderer-process"