@lvce-editor/main-area-worker 9.70.0 → 9.71.0

package/dist/mainAreaWorkerMain.js

@@ -1934,6 +1934,7 @@ const withActiveEditorChangeAsync = fn => {
 
 const registry = create$4();
 const {
+  dispose: dispose$1,
   get: get$1,
   getCommandIds,
   getKeys: getKeys$1,
@@ -2911,6 +2912,16 @@ const diff2 = uid => {
   return result;
 };
 
+const dispose = async uid => {
+  const instance = get$1(uid);
+  if (!instance) {
+    return;
+  }
+  const editorUids = instance.newState.layout.groups.flatMap(group => group.tabs.map(tab => tab.editorUid).filter(id => id !== -1));
+  dispose$1(uid);
+  await disposeEditors(editorUids);
+};
+
 const state = {
   connected: false
 };
@@ -8091,6 +8102,163 @@ const initialize$1 = async () => {
   // Kept as a compatibility command for existing renderer startup code.
 };
 
+const isCurrent = context => {
+  const state = context.getState();
+  return !state.disposed && get$1(state.uid)?.newState === state;
+};
+const renderPending = async context => {
+  if (!isCurrent(context)) {
+    return;
+  }
+  const {
+    applicationId,
+    uid
+  } = context.getState();
+  await invoke$1(applicationId, 'Layout.renderMainAreaPending', uid);
+};
+const loadRestoredTab = async (context, tab) => {
+  const isPending = () => {
+    const latestTab = findTabById(context.getState(), tab.id)?.tab;
+    return isCurrent(context) && latestTab?.editorUid === tab.editorUid && latestTab.loadingState === 'loading';
+  };
+  try {
+    const state = context.getState();
+    const moduleId = await getViewletModuleIdForEditorInput(tab.editorInput, state.applicationId);
+    if (!isPending()) {
+      return;
+    }
+    if (!moduleId) {
+      throw new Error('Could not determine editor type for this URI');
+    }
+    const latestState = context.getState();
+    const location = findTabById(latestState, tab.id);
+    const bounds = getSelectedTabBounds(latestState, location.groupId);
+    await createViewletContent(moduleId, tab.editorUid, tab.id, bounds, tab.uri, [{
+      focus: false
+    }], state.applicationId);
+    if (!isPending()) {
+      await disposeEditors([tab.editorUid]);
+      return;
+    }
+    const beforeReady = context.getState();
+    const readyState = await context.updateState(current => handleViewletReady(current, tab.editorUid));
+    await notifyActiveEditorChange(beforeReady, readyState);
+    await notifyMountedViewlets(beforeReady, readyState);
+    await renderPending(context);
+    // Optional metadata must never hold up editor readiness or another group.
+    const title = await getViewletTitle(tab.editorUid);
+    if (!isCurrent(context) || findTabById(context.getState(), tab.id)?.tab.editorUid !== tab.editorUid) {
+      return;
+    }
+    if (title) {
+      await context.updateState(current => handleViewletReady(current, tab.editorUid, title));
+    }
+    await renderPending(context);
+  } catch (error) {
+    if (!isPending()) {
+      return;
+    }
+    await disposeEditors([tab.editorUid]);
+    await context.updateState(current => updateTab(current, tab.id, {
+      editorUid: -1,
+      errorMessage: error instanceof Error ? error.message : 'Failed to restore editor',
+      loadingState: 'error'
+    }));
+    await renderPending(context);
+  }
+};
+const loadHomeDir = async context => {
+  const homeDirUri = await loadHomeDirUri(context.getState().applicationId);
+  if (!isCurrent(context)) {
+    return;
+  }
+  await context.updateState(state => updateTabUriTitles({
+    ...state,
+    homeDirUri
+  }));
+  await renderPending(context);
+};
+const loadIcons = async context => {
+  const {
+    fileIconCache,
+    updatedLayout
+  } = await loadFileIcons(context.getState());
+  if (!isCurrent(context)) {
+    return;
+  }
+  const icons = new Map(updatedLayout.groups.flatMap(group => group.tabs.map(tab => [tab.id, tab])));
+  // Metadata completion must not restore an obsolete layout or tab selection.
+  await context.updateState(state => ({
+    ...state,
+    fileIconCache: {
+      ...state.fileIconCache,
+      ...fileIconCache
+    },
+    layout: {
+      ...state.layout,
+      groups: state.layout.groups.map(group => ({
+        ...group,
+        tabs: group.tabs.map(tab => {
+          const restored = icons.get(tab.id);
+          return restored && restored.uri === tab.uri ? {
+            ...tab,
+            icon: restored.icon
+          } : tab;
+        })
+      }))
+    }
+  }));
+  await renderPending(context);
+};
+const loadContentLater = async context => {
+  const state = context.getState();
+  // Older renderers discover this lifecycle hook but still use loadContent.
+  if (state.pendingRestoreTabIds === undefined) {
+    return;
+  }
+  const pendingIds = new Set(state.pendingRestoreTabIds);
+  const tabs = state.layout.groups.flatMap(group => group.tabs.filter(tab => pendingIds.has(tab.id) && tab.loadingState === 'loading'));
+  await context.updateState(current => ({
+    ...current,
+    pendingRestoreTabIds: []
+  }));
+  await Promise.all([loadHomeDir(context), loadIcons(context), ...tabs.map(tab => loadRestoredTab(context, tab))]);
+};
+
+// Restore the shell without depending on any editor, workspace, or icon RPC.
+const loadContentShell = (state, savedState) => {
+  const layout = tryRestoreLayout(savedState) ?? {
+    activeGroupId: -1,
+    direction: Horizontal,
+    groups: []
+  };
+  const {
+    groups
+  } = layout;
+  reserve(groups.flatMap(group => [group.id, ...group.tabs.map(tab => tab.id)]));
+  return updateTabUriTitles({
+    ...state,
+    initial: false,
+    layout: {
+      ...layout,
+      groups: groups.map(group => ({
+        ...group,
+        tabs: group.tabs.map(tab => {
+          if (tab.id !== group.activeTabId || !tab.uri || tab.loadingState === 'binary') {
+            return tab;
+          }
+          return {
+            ...tab,
+            editorUid: create$2(),
+            loadingState: 'loading'
+          };
+        })
+      }))
+    },
+    pendingRestoreTabIds: groups.flatMap(group => group.tabs.filter(tab => tab.id === group.activeTabId && tab.uri && tab.loadingState !== 'binary').map(tab => tab.id))
+  });
+};
+
 const hasTargetGroup = groupId => {
   return groupId !== undefined && groupId >= 0;
 };
@@ -9305,6 +9473,7 @@ const commandMap = {
   'MainArea.copyRelativePath': wrapSerialCommand(copyRelativePath$1),
   'MainArea.create': create$1,
   'MainArea.diff2': diff2,
+  'MainArea.dispose': dispose,
   'MainArea.flipEditorLayout': wrapSerialCommand(flipLayout),
   'MainArea.focus': wrapSerialCommand(focus),
   'MainArea.focusNext': wrapSerialCommand(focusNextTab),
@@ -9312,7 +9481,8 @@ const commandMap = {
   'MainArea.focusPrevious': wrapSerialCommand(focusPreviousTab),
   'MainArea.focusPreviousTab': wrapSerialCommand(focusPreviousTab),
   'MainArea.getActiveEditorUid': wrapGetter(getActiveEditorUid),
-  'MainArea.getCommandIds': getCommandIds,
+  // Lifecycle hooks require an explicit renderer adapter, not command discovery.
+  'MainArea.getCommandIds': () => getCommandIds().filter(id => id !== 'loadContentLater'),
   'MainArea.getComponentDom': getComponentDom,
   'MainArea.getComponentState': getComponentState,
   'MainArea.getMenuEntries': wrapGetter(getMenuEntries),
@@ -9356,6 +9526,11 @@ const commandMap = {
   'MainArea.hasDirtyTabs': wrapGetter(hasDirtyTabs),
   'MainArea.initialize': initialize$1,
   'MainArea.loadContent': loadContentTracked,
+  'MainArea.loadContentLater': wrapAsyncCommand(loadContentLater),
+  'MainArea.loadContentShell': (uid, savedState) => {
+    const instance = get$1(uid);
+    set$1(uid, instance.oldState, loadContentShell(instance.newState, savedState));
+  },
   'MainArea.moveIntoNewWindow': wrapSerialCommand(moveIntoNewWindow),
   'MainArea.newFile': wrapSerialCommand(newFile),
   'MainArea.newWindow': wrapSerialCommand(newWindow),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-area-worker",
-  "version": "9.70.0",
+  "version": "9.71.0",
   "description": "Main Area Worker",
   "repository": {
     "type": "git",