@lvce-editor/renderer-process 30.81.6 → 30.81.8

package/dist/rendererProcessMain.js

@@ -1474,15 +1474,15 @@ const commandMapRef = {};
 
 const workers$1 = new Map();
 const metadataById = new Map();
-const state$o = {
+const state$p = {
   generation: 0,
   nextId: 0
 };
-const getGeneration = () => state$o.generation;
+const getGeneration = () => state$p.generation;
 const createRuntimeName = (name, parentName) => {
-  state$o.nextId++;
-  const id = `worker-${state$o.nextId}`;
-  const runtimeId = `worker-${String(state$o.nextId).padStart(2, '0')}`;
+  state$p.nextId++;
+  const id = `worker-${state$p.nextId}`;
+  const runtimeId = `worker-${String(state$p.nextId).padStart(2, '0')}`;
   let parent;
   if (parentName) {
     parent = metadataById.values().find(worker => worker.name === parentName);
@@ -1500,8 +1500,8 @@ const createRuntimeName = (name, parentName) => {
   metadataById.set(id, metadata);
   return metadata;
 };
-const track = (worker, startedIn = state$o.generation, trackedWorker) => {
-  if (startedIn !== state$o.generation) {
+const track = (worker, startedIn = state$p.generation, trackedWorker) => {
+  if (startedIn !== state$p.generation) {
     worker.terminate();
     throw new Error('Worker launch canceled by application restart');
   }
@@ -1535,7 +1535,7 @@ const terminate$1 = id => {
 };
 const getWorkers$1 = () => workers$1.values().toArray();
 const terminateAll = () => {
-  state$o.generation++;
+  state$p.generation++;
   const retiring = workers$1.keys().toArray();
   workers$1.clear();
   metadataById.clear();
@@ -1671,8 +1671,8 @@ const launchRendererWorker = async () => {
   });
 };
 
-const selector = 'script.RendererWorkerTrace';
-const state$n = {
+const selector$1 = 'script.RendererWorkerTrace';
+const state$o = {
   enabled: false,
   entries: []
 };
@@ -1722,14 +1722,14 @@ const isCommand = value => {
 };
 const initialize$1 = search => {
   const searchParams = new URLSearchParams(search);
-  state$n.enabled = searchParams.has('traceRendererWorker');
-  state$n.entries = [];
+  state$o.enabled = searchParams.has('traceRendererWorker');
+  state$o.entries = [];
 };
 const record = (direction, method, params) => {
-  if (!state$n.enabled) {
+  if (!state$o.enabled) {
     return;
   }
-  state$n.entries.push({
+  state$o.entries.push({
     direction,
     method,
     params: serialize(params),
@@ -1737,7 +1737,7 @@ const record = (direction, method, params) => {
   });
 };
 const listen$1 = rpc => {
-  if (!state$n.enabled) {
+  if (!state$o.enabled) {
     return;
   }
   const ipc = rpc.ipc;
@@ -1752,15 +1752,15 @@ const listen$1 = rpc => {
   });
 };
 const exportToDom = () => {
-  if (!state$n.enabled) {
+  if (!state$o.enabled) {
     return;
   }
-  const existing = document.querySelector(selector);
+  const existing = document.querySelector(selector$1);
   const script = existing || document.createElement('script');
   script.className = 'RendererWorkerTrace';
   script.type = 'application/json';
   script.textContent = JSON.stringify({
-    entries: state$n.entries,
+    entries: state$o.entries,
     version: 1
   });
   if (!existing) {
@@ -1768,49 +1768,49 @@ const exportToDom = () => {
   }
 };
 const scheduleExport = () => {
-  if (!state$n.enabled) {
+  if (!state$o.enabled) {
     return;
   }
   queueMicrotask(exportToDom);
 };
 
-const state$m = {
+const state$n = {
   rpc: undefined
 };
 const hydrate$4 = async () => {
   const result = await launchRendererWorker();
   if (isError(result)) {
-    state$m.rpc = undefined;
+    state$n.rpc = undefined;
     return result;
   }
-  state$m.rpc = result.value;
+  state$n.rpc = result.value;
   listen$1(result.value);
   return success(undefined);
 };
 
 // TODO needed?
-const dispose$p = async () => {
-  const rpc = state$m.rpc;
-  state$m.rpc = undefined;
+const dispose$q = async () => {
+  const rpc = state$n.rpc;
+  state$n.rpc = undefined;
   await rpc?.dispose();
 };
 const send$1 = (method, ...params) => {
   record('sent', method, params);
   // @ts-ignore
-  state$m.rpc.send(method, ...params);
+  state$n.rpc.send(method, ...params);
 };
 const invoke$1 = (method, ...params) => {
   record('sent', method, params);
   // @ts-ignore
-  return state$m.rpc.invoke(method, ...params);
+  return state$n.rpc.invoke(method, ...params);
 };
 const invokeAndTransfer = (method, ...params) => {
   record('sent', method, params);
   // @ts-ignore
-  return state$m.rpc.invokeAndTransfer(method, ...params);
+  return state$n.rpc.invokeAndTransfer(method, ...params);
 };
 
-const state$l = {
+const state$m = {
   client: undefined,
   enabled: false,
   lastError: '',
@@ -1820,38 +1820,38 @@ const state$l = {
 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$l.lastError = error instanceof Error ? error.message : String(error);
-  state$l.stopObserving?.();
-  state$l.stopObserving = undefined;
-  console.warn(`Session replay: ${state$l.lastError}`);
+  state$m.lastError = error instanceof Error ? error.message : String(error);
+  state$m.stopObserving?.();
+  state$m.stopObserving = undefined;
+  console.warn(`Session replay: ${state$m.lastError}`);
 };
 
 // Retain snapshot recording for older renderer workers during dependency rollout.
 const configure$1 = async options => {
-  state$l.stopObserving?.();
-  state$l.stopObserving = undefined;
-  state$l.enabled = false;
-  if (state$l.client) {
+  state$m.stopObserving?.();
+  state$m.stopObserving = undefined;
+  state$m.enabled = false;
+  if (state$m.client) {
     try {
-      await state$l.client.invoke('stop');
+      await state$m.client.invoke('stop');
     } catch (error) {
       report(error);
     }
     // Live channels still need their proxy after capture stops.
-    if (!state$l.proxy) {
-      state$l.client.dispose();
-      state$l.client = undefined;
+    if (!state$m.proxy) {
+      state$m.client.dispose();
+      state$m.client = undefined;
     }
   }
   if (!options.local && !options.upload) return '';
-  if (state$l.proxy) throw new Error(reloadMessage);
-  state$l.lastError = '';
+  if (state$m.proxy) throw new Error(reloadMessage);
+  state$m.lastError = '';
   const client = createClient(workerUrl);
   try {
     const id = await client.invoke('start', options);
-    state$l.stopObserving = observe(document, (type, data) => client.invoke('record', type, data), report);
-    state$l.client = client;
-    state$l.enabled = true;
+    state$m.stopObserving = observe(document, (type, data) => client.invoke('record', type, data), report);
+    state$m.client = client;
+    state$m.enabled = true;
     return id;
   } catch (error) {
     client.dispose();
@@ -1859,7 +1859,7 @@ const configure$1 = async options => {
   }
 };
 const configureProxy = async (options, port) => {
-  if (state$l.client || !options.local && !options.upload) {
+  if (state$m.client || !options.local && !options.upload) {
     port.close();
     throw new Error(reloadMessage);
   }
@@ -1872,25 +1872,25 @@ const configureProxy = async (options, port) => {
       commandMap: commandMapRef,
       messagePort: proxyPort
     });
-    const original = state$m.rpc;
-    state$m.rpc = {
+    const original = state$n.rpc;
+    state$n.rpc = {
       ...rpc,
       async dispose() {
         try {
           await rpc.dispose();
         } finally {
           client.dispose();
-          state$l.client = undefined;
-          state$l.enabled = false;
-          state$l.proxy = false;
+          state$m.client = undefined;
+          state$m.enabled = false;
+          state$m.proxy = false;
           await original?.dispose();
         }
       }
     };
-    state$l.client = client;
-    state$l.enabled = true;
-    state$l.proxy = true;
-    state$l.lastError = '';
+    state$m.client = client;
+    state$m.enabled = true;
+    state$m.proxy = true;
+    state$m.lastError = '';
     return id;
   } catch (error) {
     proxyPort?.close();
@@ -1900,21 +1900,21 @@ const configureProxy = async (options, port) => {
   }
 };
 const getSession = async () => {
-  if (!state$l.enabled || !state$l.client) throw new Error('Session replay is disabled in settings');
-  return state$l.client.invoke('export');
+  if (!state$m.enabled || !state$m.client) throw new Error('Session replay is disabled in settings');
+  return state$m.client.invoke('export');
 };
 const getStatus$1 = async () => {
-  if (!state$l.client) return {
+  if (!state$m.client) return {
     enabled: false,
-    error: state$l.lastError
+    error: state$m.lastError
   };
   return {
-    enabled: state$l.enabled,
-    ...(await state$l.client.invoke('status')),
-    captureError: state$l.lastError
+    enabled: state$m.enabled,
+    ...(await state$m.client.invoke('status')),
+    captureError: state$m.lastError
   };
 };
-const flush = async () => state$l.client?.invoke('flush');
+const flush = async () => state$m.client?.invoke('flush');
 const openLocalFile = async () => {
   const input = document.createElement('input');
   input.type = 'file';
@@ -1971,13 +1971,13 @@ const initializeLayout = async href => {
   }
   return true;
 };
-const dispose$o = async () => {
-  state$l.stopObserving?.();
-  state$l.stopObserving = undefined;
-  const client = state$l.client;
-  state$l.client = undefined;
-  state$l.enabled = false;
-  state$l.proxy = false;
+const dispose$p = async () => {
+  state$m.stopObserving?.();
+  state$m.stopObserving = undefined;
+  const client = state$m.client;
+  state$m.client = undefined;
+  state$m.enabled = false;
+  state$m.proxy = false;
   if (client) {
     try {
       await client.invoke('flush');
@@ -2049,7 +2049,7 @@ const apply = (uid, args) => {
   for (const index of indices) scaled[index] *= view.speed;
   return scaled;
 };
-const dispose$n = uid => {
+const dispose$o = uid => {
   views.delete(uid);
 };
 
@@ -2089,10 +2089,10 @@ const measurePrefix = (text, offset, fontWeight, fontSize, fontFamily, letterSpa
 };
 
 const pendingInputs = new Set();
-const state$k = {
+const state$l = {
   shortcut: undefined
 };
-const hasPending = () => Boolean(state$k.shortcut || pendingInputs.size > 0);
+const hasPending = () => Boolean(state$l.shortcut || pendingInputs.size > 0);
 const settle = async result => {
   try {
     await result;
@@ -2110,7 +2110,7 @@ const runAfterShortcut = async (previous, run) => {
 };
 const runInput = run => {
   // Inputs in the same burst run concurrently so the worker can coalesce renders.
-  const result = runAfterShortcut(state$k.shortcut, run);
+  const result = runAfterShortcut(state$l.shortcut, run);
   const settled = settle(result);
   pendingInputs.add(settled);
   void removeInput(settled);
@@ -2122,15 +2122,15 @@ const runAfterInputs = async (earlier, run) => {
 };
 const clearShortcut = async settled => {
   await settled;
-  if (state$k.shortcut === settled) state$k.shortcut = undefined;
+  if (state$l.shortcut === settled) state$l.shortcut = undefined;
 };
 const runShortcut = run => {
   // Snapshot only earlier input; later input waits for this shortcut instead.
   const earlier = [...pendingInputs];
-  if (state$k.shortcut) earlier.push(state$k.shortcut);
+  if (state$l.shortcut) earlier.push(state$l.shortcut);
   const result = runAfterInputs(earlier, run);
   const settled = settle(result);
-  state$k.shortcut = settled;
+  state$l.shortcut = settled;
   void clearShortcut(settled);
   return result;
 };
@@ -2637,7 +2637,7 @@ const createIdGenerator = () => {
 };
 const create$z = createIdGenerator();
 
-const state$j = Object.create(null);
+const state$k = Object.create(null);
 const retainString = (item, index) => {
   const value = new Promise(resolve => {
     item.getAsString(resolve);
@@ -2688,25 +2688,25 @@ const retainItems = dataTransfer => {
 };
 const addItems = items => {
   const id = create$z();
-  state$j[id] = items;
+  state$k[id] = items;
   return id;
 };
 const add$2 = dataTransfer => {
   return addItems(retainItems(dataTransfer));
 };
 const acquire$2 = id => {
-  const items = state$j[id];
+  const items = state$k[id];
   if (!items) {
     throw new Error(`Drop data not found: ${id}`);
   }
-  delete state$j[id];
+  delete state$k[id];
   return items;
 };
 
-const state$i = Object.create(null);
+const state$j = Object.create(null);
 const acquire$1 = id => {
-  const promise = state$i[id];
-  delete state$i[id];
+  const promise = state$j[id];
+  delete state$j[id];
   return promise;
 };
 const getFileHandles = async ids => {
@@ -2716,7 +2716,7 @@ const getFileHandles = async ids => {
 };
 const add$1 = promise => {
   const id = create$z();
-  state$i[id] = promise;
+  state$j[id] = promise;
   return id;
 };
 const addFileHandle$1 = fileHandle => {
@@ -2910,14 +2910,14 @@ const getEventListenerArgs = (params, event) => {
   return serialized;
 };
 
-const state$h = {
+const state$i = {
   ipc: undefined
 };
 const getIpc = () => {
-  return state$h.ipc;
+  return state$i.ipc;
 };
 const setIpc = value => {
-  state$h.ipc = value;
+  state$i.ipc = value;
 };
 
 const nameAnonymousFunction$1 = (fn, name) => {
@@ -4654,34 +4654,34 @@ const launchDragAndDropWorker = async () => {
   }
 };
 
-const state$g = {
+const state$h = {
   rpc: undefined
 };
 const hydrate$3 = async () => {
   const result = await launchDragAndDropWorker();
   if (isError(result)) {
-    state$g.rpc = undefined;
+    state$h.rpc = undefined;
     return result;
   }
-  state$g.rpc = result.value;
+  state$h.rpc = result.value;
   return success(undefined);
 };
 const handleMessagePort$1 = async port => {
-  if (!state$g.rpc) {
+  if (!state$h.rpc) {
     const result = await hydrate$3();
     if (isError(result)) {
       throw result.error;
     }
   }
-  const rpc = state$g.rpc;
+  const rpc = state$h.rpc;
   if (!rpc) {
     throw new Error('Drag And Drop Worker failed to initialize');
   }
   await rpc.invokeAndTransfer('DragAndDrop.handleMessagePort', port);
 };
-const dispose$m = async () => {
-  const rpc = state$g.rpc;
-  state$g.rpc = undefined;
+const dispose$n = async () => {
+  const rpc = state$h.rpc;
+  state$h.rpc = undefined;
   await rpc?.dispose();
 };
 
@@ -4740,12 +4740,12 @@ const unregisterView = uid => {
   viewRpcIds.delete(uid);
 };
 
-const state$f = {
+const state$g = {
   snapshot: undefined
 };
-const get$7 = () => state$f.snapshot;
+const get$7 = () => state$g.snapshot;
 const set$9 = value => {
-  state$f.snapshot = value;
+  state$g.snapshot = value;
 };
 
 const ipcs = Object.create(null);
@@ -5168,7 +5168,7 @@ const create$t = async ({
   // @ts-ignore
   return module.create(options);
 };
-const dispose$l = id => {
+const dispose$m = id => {
   const worker = remove$3(id);
   if (worker) {
     remove$6(worker);
@@ -5299,32 +5299,32 @@ const launchWorkers = async () => {
   return success(undefined);
 };
 
-const state$e = {
+const state$f = {
   renderer: undefined
 };
 const configure = options => {
   const cache = options?.cache;
-  state$e.renderer = cache?.dom > 0 || cache?.text > 0 ? createRenderer(options) : undefined;
+  state$f.renderer = cache?.dom > 0 || cache?.text > 0 ? createRenderer(options) : undefined;
 };
 const render = (nodes, eventMap = {}, newEventMap = {}) => {
-  return state$e.renderer?.render(nodes, eventMap, newEventMap) || render$1(nodes, eventMap, newEventMap);
+  return state$f.renderer?.render(nodes, eventMap, newEventMap) || render$1(nodes, eventMap, newEventMap);
 };
 const renderInto = (parent, nodes, eventMap = {}, newEventMap = {}) => {
-  if (state$e.renderer) {
-    state$e.renderer.renderInto(parent, nodes, eventMap, newEventMap);
+  if (state$f.renderer) {
+    state$f.renderer.renderInto(parent, nodes, eventMap, newEventMap);
     return;
   }
   renderInto$1(parent, nodes, eventMap);
 };
 const applyPatch$1 = (element, patches, eventMap = {}, id = 0) => {
-  if (state$e.renderer) {
-    state$e.renderer.applyPatch(element, patches, eventMap, id);
+  if (state$f.renderer) {
+    state$f.renderer.applyPatch(element, patches, eventMap, id);
     return;
   }
   applyPatch$2(element, patches, eventMap, id);
 };
-const dispose$k = root => {
-  state$e.renderer?.dispose(root);
+const dispose$l = root => {
+  state$f.renderer?.dispose(root);
 };
 
 const applyPatch = (element, patches, eventMap = {}, id = 0) => {
@@ -5337,6 +5337,81 @@ const attachEvents$7 = ($Node, eventMap) => {
   }
 };
 
+const selector = 'textarea[name="composer"]';
+const state$e = {
+  handled: false
+};
+const hasFocus = () => !!document.activeElement && document.activeElement !== document.body && document.activeElement !== document.documentElement;
+const dispose$k = viewletId => {
+  const pending = state$e.pending;
+  if (pending && pending.id === viewletId) pending.cancel();
+};
+
+// The route's composer can arrive after the initial workbench frame.
+const focus$d = viewletId => {
+  if (state$e.handled || !/(?:^|\/)chat\/?$/.test(location.pathname)) {
+    return;
+  }
+  if (!get$b(viewletId)?.state.$Viewlet.querySelector(selector)) {
+    return;
+  }
+  state$e.handled = true;
+  if (hasFocus()) {
+    return;
+  }
+  let cancelled = false;
+  let mutations;
+  let sizes;
+  let observed;
+  const cancel = () => {
+    cancelled = true;
+    document.removeEventListener('focusin', cancel, true);
+    mutations?.disconnect();
+    sizes?.disconnect();
+    state$e.pending = undefined;
+  };
+  state$e.pending = {
+    cancel,
+    id: viewletId
+  };
+  document.addEventListener('focusin', cancel, {
+    capture: true
+  });
+  const tryFocus = () => {
+    if (cancelled) return;
+    const input = get$b(viewletId)?.state.$Viewlet.querySelector(selector);
+    if (hasFocus() || !(input instanceof HTMLTextAreaElement)) {
+      cancel();
+      return;
+    }
+    if (input.isConnected && input.getClientRects().length > 0) {
+      input.focus({
+        preventScroll: true
+      });
+      if (document.activeElement === input) {
+        cancel();
+        return;
+      }
+    }
+    // A detached or hidden first render is not the user's focus opportunity.
+    // Watch actual mounting/layout rather than consuming it after a frame count.
+    mutations ??= new MutationObserver(tryFocus);
+    sizes ??= new ResizeObserver(tryFocus);
+    mutations.observe(document.body, {
+      attributeFilter: ['class', 'style', 'hidden', 'disabled', 'inert'],
+      attributes: true,
+      childList: true,
+      subtree: true
+    });
+    if (observed !== input) {
+      sizes.disconnect();
+      sizes.observe(input);
+      observed = input;
+    }
+  };
+  requestAnimationFrame(() => requestAnimationFrame(tryFocus));
+};
+
 const state$d = {
   styleSheets: Object.create(null),
   texts: Object.create(null)
@@ -10296,6 +10371,7 @@ const setDom2 = (viewletId, dom) => {
       $Viewlet: $NewViewlet
     }
   });
+  focus$d(viewletId);
 };
 const setTreePatches = (uid, patches) => {
   if (patches.length === 0) {
@@ -10390,11 +10466,12 @@ const commitPending = (uid, transactionId) => {
   executeCommands(take(uid, transactionId, getFocusVersion()));
 };
 const dispose$4 = id => {
+  dispose$k(id);
   try {
     number(id);
     restoreComponentDom(id);
     dispose$j(id);
-    dispose$n(id);
+    dispose$o(id);
     unregisterView(id);
     dispose$i(id);
     const instance = get$b(id);
@@ -10405,7 +10482,7 @@ const dispose$4 = id => {
     if (instance.factory.dispose) {
       instance.factory.dispose(instance.state);
     }
-    dispose$k(instance.state.$Viewlet);
+    dispose$l(instance.state.$Viewlet);
     if (instance.state.$Viewlet?.isConnected) {
       instance.state.$Viewlet.remove();
     }
@@ -10742,9 +10819,9 @@ const restart = async () => {
     const snapshot = await invoke$1('Reload.prepareHotReload');
     set$9(snapshot);
     await invoke$1('Reload.retire');
-    await dispose$o();
     await dispose$p();
-    await dispose$m();
+    await dispose$q();
+    await dispose$n();
     terminateAll();
     clear$2();
     clear$4();
@@ -12808,7 +12885,7 @@ const commandMap = {
   'HotReload.request': request,
   'InitData.getInitData': getInitData,
   'IpcParent.create': create$t,
-  'IpcParent.dispose': dispose$l,
+  'IpcParent.dispose': dispose$m,
   'KeyBindings.setIdentifiers': setIdentifiers,
   'Layout.getBounds': getBounds,
   'Location.getHref': getHref,

package/package.json

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