@lvce-editor/renderer-process 30.12.4 → 30.13.1

package/dist/rendererProcessMain.js

@@ -118,25 +118,25 @@ const confirm = message => {
   return window.confirm(message);
 };
 
-const state$a = {
+const state$b = {
   styleSheets: Object.create(null),
   texts: Object.create(null)
 };
 const set$b = (id, sheet) => {
-  state$a.styleSheets[id] = sheet;
+  state$b.styleSheets[id] = sheet;
 };
 const get$b = id => {
-  return state$a.styleSheets[id];
+  return state$b.styleSheets[id];
 };
 const setText$2 = (id, text) => {
-  state$a.texts[id] = text;
+  state$b.texts[id] = text;
 };
 const getText = id => {
-  return state$a.texts[id];
+  return state$b.texts[id];
 };
 const remove$5 = id => {
-  delete state$a.styleSheets[id];
-  delete state$a.texts[id];
+  delete state$b.styleSheets[id];
+  delete state$b.texts[id];
 };
 
 const addCssStyleSheet = (id, text) => {
@@ -338,10 +338,10 @@ const createIdGenerator = () => {
 };
 const create$L = createIdGenerator();
 
-const state$9 = Object.create(null);
+const state$a = Object.create(null);
 const acquire$1 = id => {
-  const promise = state$9[id];
-  delete state$9[id];
+  const promise = state$a[id];
+  delete state$a[id];
   return promise;
 };
 const getFileHandles$1 = async ids => {
@@ -351,7 +351,7 @@ const getFileHandles$1 = async ids => {
 };
 const add$1 = promise => {
   const id = create$L();
-  state$9[id] = promise;
+  state$a[id] = promise;
   return id;
 };
 const addFileHandle$1 = fileHandle => {
@@ -528,14 +528,14 @@ const getEventListenerArgs = (params, event) => {
   return serialized;
 };
 
-const state$8 = {
+const state$9 = {
   ipc: undefined
 };
 const getIpc = () => {
-  return state$8.ipc;
+  return state$9.ipc;
 };
 const setIpc = value => {
-  state$8.ipc = value;
+  state$9.ipc = value;
 };
 
 const nameAnonymousFunction$1 = (fn, name) => {
@@ -1457,6 +1457,10 @@ const removeProp = ($Element, key) => {
   $Element.removeAttribute(attributeName);
 };
 const setProp = ($Element, key, value, eventMap, newEventMap) => {
+  if (key.startsWith('aria-')) {
+    $Element.setAttribute(key, String(value));
+    return;
+  }
   switch (key) {
     case 'ariaActivedescendant':
       setOptionalAttribute($Element, 'aria-activedescendant', value);
@@ -1544,18 +1548,20 @@ const renderDomElement = (element, eventMap, newEventMap) => {
   setProps($Element, element, eventMap, newEventMap);
   return $Element;
 };
-const renderReferenceNode = element => {
+const renderReferenceNode = (element, eventMap, newEventMap) => {
   const instance = get$a(element.uid);
   if (!instance || !instance.state) {
     return document.createTextNode('Reference node not found');
   }
   const $Node = instance.state.$Viewlet;
+  const props = Object.fromEntries(Object.entries(element).filter(([key]) => key !== 'uid'));
+  setProps($Node, props, eventMap, newEventMap);
   return $Node;
 };
 const render$1 = (element, eventMap, newEventMap) => {
   switch (element.type) {
     case Reference:
-      return renderReferenceNode(element);
+      return renderReferenceNode(element, eventMap, newEventMap);
     case Text:
       return renderDomTextNode(element);
     default:
@@ -3580,6 +3586,109 @@ const launchRendererWorker = async () => {
   });
 };
 
+const selector = 'script.RendererWorkerTrace';
+const state$8 = {
+  enabled: false,
+  entries: []
+};
+const serialize = value => {
+  const seen = new WeakSet();
+  const text = JSON.stringify(value, (_key, currentValue) => {
+    if (typeof currentValue === 'bigint') {
+      return `${currentValue}n`;
+    }
+    if (typeof currentValue !== 'object' || currentValue === null) {
+      return currentValue;
+    }
+    if (seen.has(currentValue)) {
+      return '[Circular]';
+    }
+    seen.add(currentValue);
+    if (currentValue instanceof ArrayBuffer) {
+      return {
+        byteLength: currentValue.byteLength,
+        type: 'ArrayBuffer'
+      };
+    }
+    if (ArrayBuffer.isView(currentValue)) {
+      return {
+        byteLength: currentValue.byteLength,
+        type: currentValue.constructor.name
+      };
+    }
+    if (currentValue instanceof Error) {
+      return {
+        message: currentValue.message,
+        name: currentValue.name,
+        stack: currentValue.stack
+      };
+    }
+    if (currentValue.constructor?.name === 'MessagePort') {
+      return {
+        type: 'MessagePort'
+      };
+    }
+    return currentValue;
+  });
+  return JSON.parse(text);
+};
+const isCommand = value => {
+  return typeof value === 'object' && value !== null && 'method' in value && typeof value.method === 'string';
+};
+const initialize = search => {
+  const searchParams = new URLSearchParams(search);
+  state$8.enabled = searchParams.has('traceRendererWorker');
+  state$8.entries = [];
+};
+const record = (direction, method, params) => {
+  if (!state$8.enabled) {
+    return;
+  }
+  state$8.entries.push({
+    direction,
+    method,
+    params: serialize(params),
+    timestamp: performance.now()
+  });
+};
+const listen = rpc => {
+  if (!state$8.enabled) {
+    return;
+  }
+  const ipc = rpc.ipc;
+  if (!ipc) {
+    return;
+  }
+  ipc.addEventListener('message', event => {
+    const message = ipc.getData(event);
+    if (isCommand(message)) {
+      record('received', message.method, message.params || []);
+    }
+  });
+};
+const exportToDom = () => {
+  if (!state$8.enabled) {
+    return;
+  }
+  const existing = document.querySelector(selector);
+  const script = existing || document.createElement('script');
+  script.className = 'RendererWorkerTrace';
+  script.type = 'application/json';
+  script.textContent = JSON.stringify({
+    entries: state$8.entries,
+    version: 1
+  });
+  if (!existing) {
+    document.body.append(script);
+  }
+};
+const scheduleExport = () => {
+  if (!state$8.enabled) {
+    return;
+  }
+  queueMicrotask(exportToDom);
+};
+
 const state$7 = {
   rpc: undefined
 };
@@ -3590,6 +3699,7 @@ const hydrate$3 = async () => {
     return result;
   }
   state$7.rpc = result.value;
+  listen(result.value);
   return success(undefined);
 };
 
@@ -3600,18 +3710,24 @@ const dispose$k = () => {
   }
 };
 const send = (method, ...params) => {
+  record('sent', method, params);
   // @ts-ignore
   state$7.rpc.send(method, ...params);
 };
 const invoke$1 = (method, ...params) => {
+  record('sent', method, params);
   // @ts-ignore
   return state$7.rpc.invoke(method, ...params);
 };
 const sendAndTransfer = message => {
+  if (Array.isArray(message) && typeof message[0] === 'string') {
+    record('sent', message[0], message.slice(1));
+  }
   // @ts-expect-error
   state$7.rpc.sendAndTransfer(message);
 };
 const invokeAndTransfer = (method, ...params) => {
+  record('sent', method, params);
   // @ts-ignore
   return state$7.rpc.invokeAndTransfer(method, ...params);
 };
@@ -4965,6 +5081,7 @@ const showOverlay = (state, background, text, actions = []) => {
   const $actions = actions.map(createAction);
   $TestOverlay.append(span, ...$actions);
   document.body.append($TestOverlay);
+  scheduleExport();
 };
 const showTestResults = text => {
   const existing = document.querySelector('.TestResults');
@@ -4975,6 +5092,7 @@ const showTestResults = text => {
   if (!existing) {
     document.body.append($TestResults);
   }
+  scheduleExport();
 };
 const performAction = async (locator, fnName, options) => {
   object(locator);
@@ -9938,6 +10056,7 @@ const enable = async window => {
 };
 
 const main = async () => {
+  initialize(location.search);
   Object.assign(commandMapRef, commandMap);
   enable(window);
   state$1.modules[ColorPicker] = ViewletColorPicker;

package/package.json

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