@lvce-editor/output-view 1.18.0 → 2.0.0

package/dist/outputViewWorkerMain.js

@@ -515,7 +515,7 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
+const set$8 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -534,7 +534,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$4(id, resolve);
+  set$8(id, resolve);
   return {
     id,
     promise
@@ -879,10 +879,10 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$2 = (ipc, method, ...params) => {
+const invoke$5 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
@@ -918,10 +918,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$2(ipc, method, ...params);
+      return invoke$5(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$3(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1007,6 +1007,25 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$4
 };
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invoke,
+    invokeAndTransfer: invoke,
+    invocations
+  };
+  return mockRpc;
+};
 
 const toCommandId = key => {
   const dotIndex = key.indexOf('.');
@@ -1041,10 +1060,11 @@ const create$2 = () => {
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
         const {
+          oldState,
           newState
         } = states[uid];
         const newerState = await fn(newState, ...args);
-        if (newState === newerState) {
+        if (oldState === newerState || newState === newerState) {
           return;
         }
         const latest = states[uid];
@@ -1092,16 +1112,42 @@ const terminate = () => {
   globalThis.close();
 };
 
+const ToolBar = 'toolbar';
+
+const Button = 1;
+const Div = 4;
+const Input = 6;
+const Text$1 = 12;
+const A = 53;
+const Select$1 = 63;
+const Option$1 = 64;
+
+const Space = 9;
+const PageUp = 10;
+const PageDown = 11;
+const End = 255;
+const Home = 12;
+const LeftArrow = 13;
+const UpArrow = 14;
+const RightArrow = 15;
+const DownArrow = 16;
+
+const Script$1 = 2;
+
+const DebugWorker = 55;
+const ExtensionHostWorker = 44;
+const FileSystemWorker$1 = 209;
+const OutputWorker = 7001;
+const RendererWorker$1 = 1;
+
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set$7 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
 const create$1 = rpcId => {
   return {
     // @ts-ignore
@@ -1117,7 +1163,7 @@ const create$1 = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$g(rpcId, rpc);
+      set$7(rpcId, rpc);
     },
     async dispose() {
       const rpc = get$1(rpcId);
@@ -1125,168 +1171,523 @@ const create$1 = rpcId => {
     }
   };
 };
-const DebugWorker$1 = 55;
-const EditorWorker$1 = 99;
-const ExtensionHostWorker = 44;
-const MainProcess$1 = -5;
-const RendererWorker$1 = 1;
-const RendererProcess$1 = 1670;
-const SearchProcess$1 = 77;
-const SearchProcessElectron = 2;
-const SharedProcess$1 = 1;
-const SourceControlWorker = 66;
-const EmbedsProcess$1 = 207;
-const EmbedsWorker = 208;
-const FileSystemWorker$1 = 209;
-const FileSystemProcess$1 = 210;
-const MarkdownWorker$1 = 300;
-const CompletionWorker = 301;
-const ColorPickerWorker = 302;
-const SourceActionWorker = 303;
-const ErrorWorker$1 = 3308;
-const SyntaxHighlightingWorker$1 = 3309;
-const ClipBoardWorker$1 = 3400;
-const ClipBoardProcess$1 = 3401;
-const ExtensionDetailWorker = 3402;
-const ProblemsWorker = 3403;
-const OutputWorker = 7001;
-const RpcId = {
-  __proto__: null,
-  ClipBoardProcess: ClipBoardProcess$1,
-  ClipBoardWorker: ClipBoardWorker$1,
-  ColorPickerWorker,
-  CompletionWorker,
-  DebugWorker: DebugWorker$1,
-  EditorWorker: EditorWorker$1,
-  EmbedsProcess: EmbedsProcess$1,
-  EmbedsWorker,
-  ErrorWorker: ErrorWorker$1,
-  ExtensionDetailWorker,
-  ExtensionHostWorker,
-  FileSystemProcess: FileSystemProcess$1,
-  FileSystemWorker: FileSystemWorker$1,
-  MainProcess: MainProcess$1,
-  MarkdownWorker: MarkdownWorker$1,
-  OutputWorker,
-  ProblemsWorker,
-  RendererProcess: RendererProcess$1,
-  RendererWorker: RendererWorker$1,
-  SearchProcess: SearchProcess$1,
-  SearchProcessElectron,
-  SharedProcess: SharedProcess$1,
-  SourceActionWorker,
-  SourceControlWorker,
-  SyntaxHighlightingWorker: SyntaxHighlightingWorker$1
-};
+
 const {
-  invoke: invoke$9,
-  set: set$9} = create$1(ExtensionHostWorker);
+  invoke: invoke$4,
+  invokeAndTransfer: invokeAndTransfer$2,
+  set: set$6,
+  dispose: dispose$2
+} = create$1(ExtensionHostWorker);
+const executeReferenceProvider = async (id, offset) => {
+  // @ts-ignore
+  return invoke$4('ExtensionHostReference.executeReferenceProvider', id, offset);
+};
+const executeFileReferenceProvider = async id => {
+  // @ts-ignore
+  return invoke$4('ExtensionHostReference.executeFileReferenceProvider', id);
+};
+const getRuntimeStatus = async extensionId => {
+  // @ts-ignore
+  return invoke$4('ExtensionHost.getRuntimeStatus', extensionId);
+};
+const registerMockRpc$2 = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$6(mockRpc);
+  return mockRpc;
+};
+
 const ExtensionHost = {
   __proto__: null,
-  invoke: invoke$9,
-  set: set$9
+  dispose: dispose$2,
+  executeFileReferenceProvider,
+  executeReferenceProvider,
+  getRuntimeStatus,
+  invoke: invoke$4,
+  invokeAndTransfer: invokeAndTransfer$2,
+  registerMockRpc: registerMockRpc$2,
+  set: set$6
 };
+
 const {
-  invoke: invoke$7,
-  invokeAndTransfer: invokeAndTransfer$7,
-  set: set$7,
-  dispose: dispose$7
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$5,
+  dispose: dispose$1
 } = create$1(FileSystemWorker$1);
 const remove = async dirent => {
-  return invoke$7('FileSystem.remove', dirent);
+  return invoke$3('FileSystem.remove', dirent);
 };
 const readDirWithFileTypes = async uri => {
-  return invoke$7('FileSystem.readDirWithFileTypes', uri);
+  return invoke$3('FileSystem.readDirWithFileTypes', uri);
 };
 const getPathSeparator = async root => {
   // @ts-ignore
-  return invoke$7('FileSystem.getPathSeparator', root);
+  return invoke$3('FileSystem.getPathSeparator', root);
 };
 const getRealPath = async path => {
-  return invoke$7('FileSystem.getRealPath', path);
+  return invoke$3('FileSystem.getRealPath', path);
 };
 const stat = async dirent => {
-  return invoke$7('FileSystem.stat', dirent);
+  return invoke$3('FileSystem.stat', dirent);
 };
 const createFile = async uri => {
-  return invoke$7('FileSystem.writeFile', uri, '');
+  return invoke$3('FileSystem.writeFile', uri, '');
 };
-const readFile$1 = async uri => {
-  return invoke$7('FileSystem.readFile', uri);
+const readFile$2 = async uri => {
+  return invoke$3('FileSystem.readFile', uri);
 };
 const writeFile$1 = async (uri, content) => {
-  return invoke$7('FileSystem.writeFile', uri, content);
+  return invoke$3('FileSystem.writeFile', uri, content);
 };
 const mkdir = async uri => {
-  return invoke$7('FileSystem.mkdir', uri);
+  return invoke$3('FileSystem.mkdir', uri);
 };
 const rename = async (oldUri, newUri) => {
-  return invoke$7('FileSystem.rename', oldUri, newUri);
+  return invoke$3('FileSystem.rename', oldUri, newUri);
 };
 const copy = async (oldUri, newUri) => {
-  return invoke$7('FileSystem.copy', oldUri, newUri);
+  return invoke$3('FileSystem.copy', oldUri, newUri);
 };
 const exists = async uri => {
   // @ts-ignore
-  return invoke$7('FileSystem.exists', uri);
+  return invoke$3('FileSystem.exists', uri);
 };
 const getFolderSize$1 = async uri => {
   // @ts-ignore
-  return invoke$7('FileSystem.getFolderSize', uri);
+  return invoke$3('FileSystem.getFolderSize', uri);
 };
 const readFileAsBlob = async uri => {
   // @ts-ignore
-  return invoke$7('FileSystem.readFileAsBlob', uri);
+  return invoke$3('FileSystem.readFileAsBlob', uri);
 };
 const appendFile = async (uri, text) => {
   // @ts-ignore
-  return invoke$7('FileSystem.appendFile', uri, text);
+  return invoke$3('FileSystem.appendFile', uri, text);
 };
+const registerMockRpc$1 = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$5(mockRpc);
+  return mockRpc;
+};
+
 const FileSystemWorker = {
   __proto__: null,
   appendFile,
   copy,
   createFile,
-  dispose: dispose$7,
+  dispose: dispose$1,
   exists,
   getFolderSize: getFolderSize$1,
   getPathSeparator,
   getRealPath,
-  invoke: invoke$7,
-  invokeAndTransfer: invokeAndTransfer$7,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$1,
   mkdir,
   readDirWithFileTypes,
-  readFile: readFile$1,
+  readFile: readFile$2,
   readFileAsBlob,
+  registerMockRpc: registerMockRpc$1,
   remove,
   rename,
-  set: set$7,
+  set: set$5,
   stat,
   writeFile: writeFile$1
 };
+
 const {
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$3,
-  set: set$3$1} = create$1(RendererWorker$1);
+  invoke: invoke$2,
+  invokeAndTransfer,
+  set: set$4,
+  dispose
+} = create$1(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke$2('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke$2('FileSystemHandle.getFilePathElectron', file);
+};
+/**
+ * @deprecated
+ */
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$2('ContextMenu.show', x, y, id, ...args);
+};
+const showContextMenu2 = async (uid, menuId, x, y, args) => {
+  number(uid);
+  number(menuId);
+  number(x);
+  number(y);
+  // @ts-ignore
+  await invoke$2('ContextMenu.show2', uid, menuId, x, y, args);
+};
+const getElectronVersion = async () => {
+  return invoke$2('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke$2('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke$2(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke$2('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke$2('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke$2('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke$2('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke$2('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke$2('WebView.unregisterInterceptor', id);
+};
+const sendMessagePortToEditorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+const sendMessagePortToErrorWorker = async (port, rpcId) => {
+  const command = 'Errors.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = 'Markdown.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = 'IconTheme.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+};
 const sendMessagePortToFileSystemWorker$2 = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const readFile$1 = async uri => {
+  return invoke$2('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke$2('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke$2('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke$2('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke$2('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke$2('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke$2('IconTheme.getFolderIcon', options);
+};
+const handleWorkspaceRefresh = async () => {
+  return invoke$2('Layout.handleWorkspaceRefresh');
+};
+const closeWidget = async widgetId => {
+  return invoke$2('Viewlet.closeWidget', widgetId);
 };
 const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const confirm = async (message, options) => {
+  // @ts-ignore
+  const result = await invoke$2('ConfirmPrompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened = async () => {
+  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings$1 = async () => {
+  return invoke$2('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$2('ClipBoard.writeText', /* text */text);
+};
+const readClipBoardText = async () => {
+  return invoke$2('ClipBoard.readText');
+};
+const writeClipBoardImage = async blob => {
+  // @ts-ignore
+  await invoke$2('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke$2('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke$2('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke$2('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke$2('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke$2('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke$2('IconTheme.getIcons', requests);
+  return icons;
 };
 const activateByEvent$1 = event => {
-  return invoke$3('ExtensionHostManagement.activateByEvent', event);
+  return invoke$2('ExtensionHostManagement.activateByEvent', event);
 };
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke$2('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  // @ts-ignore
+  return invoke$2('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke$2('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const sendMessagePortToTextMeasurementWorker = async port => {
+  const command = 'TextMeasurement.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
+};
+const sendMessagePortToSourceControlWorker = async port => {
+  const command = 'SourceControl.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
+};
+const getPreference = async key => {
+  return await invoke$2('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke$2('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke$2('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke$2('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke$2('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer(
+  // @ts-ignore
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+const handleDebugScriptParsed = async script => {
+  await invoke$2('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke$2('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke$2('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke$2('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke$2('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  // @ts-ignore
+  return await invoke$2('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke$2('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke$2('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke$2('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke$2('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke$2('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke$2('Extensions.handleInput', searchValue, Script$1);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke$2('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke$2('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke$2('Preferences.getAll');
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke$2('FilePicker.showSaveFilePicker');
+};
+const getLogsDir$1 = async () => {
+  // @ts-ignore
+  return invoke$2('PlatformPaths.getLogsDir');
+};
+const measureTextBlockHeight = async (actualInput, fontFamily, fontSize, lineHeightPx, width) => {
+  return invoke$2(`MeasureTextHeight.measureTextBlockHeight`, actualInput, fontFamily, fontSize, lineHeightPx, width);
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$4(mockRpc);
+  return mockRpc;
+};
+
 const RendererWorker = {
   __proto__: null,
   activateByEvent: activateByEvent$1,
-  invoke: invoke$3,
+  applyBulkReplacement,
+  closeWidget,
+  confirm,
+  disableExtension,
+  dispose,
+  enableExtension,
+  getActiveEditorId,
+  getAllExtensions,
+  getAllPreferences,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
+  getIcons,
+  getKeyBindings: getKeyBindings$1,
+  getLogsDir: getLogsDir$1,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened,
+  getV8Version,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  handleWorkspaceRefresh,
+  installExtension,
+  invoke: invoke$2,
+  invokeAndTransfer,
+  measureTextBlockHeight,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri,
+  openUrl,
+  openWidget,
+  readClipBoardText,
+  readFile: readFile$1,
+  registerMockRpc,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker,
   sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
   sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$2,
-  set: set$3$1};
+  sendMessagePortToIconThemeWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSourceControlWorker,
+  sendMessagePortToSyntaxHighlightingWorker,
+  sendMessagePortToTextMeasurementWorker,
+  set: set$4,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showContextMenu2,
+  showErrorDialog,
+  showMessageBox,
+  showSaveFilePicker,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText
+};
 
 const {
   set: set$3,
@@ -1294,22 +1695,74 @@ const {
   writeFile
 } = FileSystemWorker;
 
+const getTextFromParts = parts => {
+  let result = '';
+  for (const part of parts) {
+    result += part.value;
+  }
+  return result;
+};
 const filterItems = (items, filterValue) => {
   if (!filterValue) {
     return items;
   }
-  return items.filter(item => item.includes(filterValue));
+  return items.filter(parts => getTextFromParts(parts).includes(filterValue));
 };
 
 const isFileNotFoundError = error => {
   return error?.message?.includes('File not found') ?? false;
 };
 
+const RE_URL = /(?:https?:\/\/\S+|file:\/\/\S+)/;
+const getLinkMatch = text => {
+  const match = text.match(RE_URL);
+  return match ? match[0] : null;
+};
+
+const Text = 1;
+const Link = 2;
+
+const parseLine = line => {
+  const parts = [];
+  let rest = line;
+  while (rest.length > 0) {
+    const match = getLinkMatch(rest);
+    if (!match) {
+      if (rest) {
+        parts.push({
+          type: Text,
+          value: rest
+        });
+      }
+      break;
+    }
+    const index = rest.indexOf(match);
+    if (index > 0) {
+      parts.push({
+        type: Text,
+        value: rest.slice(0, index)
+      });
+    }
+    parts.push({
+      type: Link,
+      value: match
+    });
+    rest = rest.slice(index + match.length);
+  }
+  if (parts.length === 0) {
+    return [{
+      type: Text,
+      value: ''
+    }];
+  }
+  return parts;
+};
+
 const loadLines = async uri => {
   try {
     // TODO use log stream, updating the output when the file is changed
     const content = await readFile(uri);
-    const lines = content.split('\n');
+    const lines = content.split('\n').map(parseLine);
     return {
       error: '',
       lines,
@@ -1377,8 +1830,8 @@ const {
   wrapCommand,
   wrapGetter,
   getKeys,
-  getCommandIds
-} = create$2();
+  getCommandIds,
+  registerCommands} = create$2();
 
 const create = (id, uri, x, y, width, height, platform, parentId) => {
   number(parentId);
@@ -1487,50 +1940,13 @@ const focusIndex = (state, index) => {
   };
 };
 
-const ToolBar = 'toolbar';
-const AriaRoles = {
-  __proto__: null,
-  ToolBar};
-const Space = 9;
-const PageUp = 10;
-const PageDown = 11;
-const End = 255;
-const Home = 12;
-const LeftArrow = 13;
-const UpArrow = 14;
-const RightArrow = 15;
-const DownArrow = 16;
-const KeyCode = {
-  __proto__: null,
-  DownArrow,
-  End,
-  Home,
-  LeftArrow,
-  PageDown,
-  PageUp,
-  RightArrow,
-  Space,
-  UpArrow
-};
 const mergeClassNames = (...classNames) => {
   return classNames.filter(Boolean).join(' ');
 };
-const Button = 1;
-const Div = 4;
-const Input = 6;
-const Text = 12;
-const Select$1 = 63;
-const Option$1 = 64;
-const VirtualDomElements = {
-  __proto__: null,
-  Button,
-  Div,
-  Input,
-  Option: Option$1,
-  Select: Select$1};
+
 const text = data => {
   return {
-    type: Text,
+    type: Text$1,
     text: data,
     childCount: 0
   };
@@ -1540,47 +1956,47 @@ const FocusProblems = 19;
 
 const getKeyBindings = () => {
   return [{
-    key: KeyCode.DownArrow,
+    key: DownArrow,
     command: 'Problems.focusNext',
     when: FocusProblems
   }, {
-    key: KeyCode.UpArrow,
+    key: UpArrow,
     command: 'Problems.focusPrevious',
     when: FocusProblems
   }, {
-    key: KeyCode.Home,
+    key: Home,
     command: 'Problems.focusFirst',
     when: FocusProblems
   }, {
-    key: KeyCode.PageUp,
+    key: PageUp,
     command: 'Problems.focusFirst',
     when: FocusProblems
   }, {
-    key: KeyCode.PageDown,
+    key: PageDown,
     command: 'Problems.focusLast',
     when: FocusProblems
   }, {
-    key: KeyCode.End,
+    key: End,
     command: 'Problems.focusLast',
     when: FocusProblems
   }, {
-    key: KeyCode.Space,
+    key: Space,
     command: 'Problems.selectCurrent',
     when: FocusProblems
   }, {
-    key: KeyCode.Home,
+    key: Home,
     command: 'Problems.focusFirst',
     when: FocusProblems
   }, {
-    key: KeyCode.End,
+    key: End,
     command: 'Problems.focusLast',
     when: FocusProblems
   }, {
-    key: KeyCode.LeftArrow,
+    key: LeftArrow,
     command: 'Problems.handleArrowLeft',
     when: FocusProblems
   }, {
-    key: KeyCode.RightArrow,
+    key: RightArrow,
     command: 'Problems.handleArrowRight',
     when: FocusProblems
   }];
@@ -1683,13 +2099,13 @@ const setupChangeListener = async (oldWatchId, newWatchId, uri) => {
     if (oldWatchId) {
       unregisterWatchCallback(oldWatchId);
       // @ts-ignore
-      await FileSystemWorker.invoke('FileSystem.unwatchFile', oldWatchId);
+      await invoke$3('FileSystem.unwatchFile', oldWatchId);
     }
     // TODO dispose old watcher
-    const rpcId = RpcId.OutputWorker;
+    const rpcId = OutputWorker;
     registerWatchCallback(newWatchId, handleFileChange);
     // @ts-ignore
-    await FileSystemWorker.invoke('FileSystem.watchFile', newWatchId, /* path */uri, rpcId);
+    await invoke$3('FileSystem.watchFile', newWatchId, /* path */uri, rpcId);
   } catch {
     // ignore
   }
@@ -1758,7 +2174,7 @@ const initializeExtensionHost = async () => {
 };
 
 const sendMessagePortToFileSystemWorker = async port => {
-  await sendMessagePortToFileSystemWorker$1(port, RpcId.OutputWorker);
+  await sendMessagePortToFileSystemWorker$1(port, OutputWorker);
 };
 
 const createFileSystemWorkerRpc = async () => {
@@ -1782,6 +2198,15 @@ const initialize = async () => {
   await Promise.all([initializeFileSystemWorker(), initializeExtensionHost()]);
 };
 
+const getLogsDir = async () => {
+  try {
+    // @ts-ignore
+    return await invoke$1('PlatformPaths.getLogsDir');
+  } catch {
+    return `file:///tmp`;
+  }
+};
+
 const Web = 1;
 
 const getSelectedItem = (selectedOption, platform) => {
@@ -1859,7 +2284,7 @@ const getExtensionOptions = async () => {
   }
 };
 
-const loadOptions = async platform => {
+const loadOptions = async (platform, logsFolderPath) => {
   const extensionOptions = await getExtensionOptions();
   if (platform === Web) {
     return extensionOptions;
@@ -1867,11 +2292,11 @@ const loadOptions = async platform => {
   return [{
     id: MainProcess,
     label: 'Main Process',
-    uri: 'file:///tmp/log-main-process.txt'
+    uri: `${logsFolderPath}/log-main-process.txt`
   }, {
     id: SharedProcess,
     label: 'Shared Process',
-    uri: 'file:///tmp/log-shared-process.txt'
+    uri: `${logsFolderPath}/log-shared-process.txt`
   }, ...extensionOptions];
 };
 
@@ -1922,13 +2347,14 @@ const loadContent = async (state, savedState) => {
     watchId
   } = state;
   const collapsedUris = getSavedCollapsedUris(savedState);
+  const logsFolderPath = await getLogsDir();
   const {
     selectedOption,
     filterValue,
     scrollLockEnabled
   } = restoreState(savedState);
   const selectedId = getSelectedItem(selectedOption, platform);
-  const options = await loadOptions(platform);
+  const options = await loadOptions(platform, logsFolderPath);
   const option = getMatchingOpen(options, selectedId);
   if (!option) {
     throw new Error('option not found');
@@ -2018,12 +2444,30 @@ const Error$1 = 'Error';
 const Line = 'Line';
 
 const parentNode = {
-  type: VirtualDomElements.Div,
+  type: Div,
   className: Line,
   childCount: 1
 };
-const getLineDom = line => {
-  return [parentNode, text(line)];
+const getLineDom = parts => {
+  const children = [];
+  for (const part of parts) {
+    if (part.type === Text) {
+      children.push(text(part.value));
+    } else {
+      children.push({
+        type: A,
+        href: part.value,
+        target: '_blank',
+        rel: 'noopener noreferrer',
+        childCount: 1
+      }, text(part.value));
+    }
+  }
+  const lineNode = {
+    ...parentNode,
+    childCount: children.length
+  };
+  return [lineNode, ...children];
 };
 
 const getContentDom = (lines, error) => {
@@ -2031,7 +2475,7 @@ const getContentDom = (lines, error) => {
     return [];
   }
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: OutputContent,
     role: 'log',
     tabIndex: 0,
@@ -2043,7 +2487,7 @@ const LogFileNotFound = 1;
 
 const getLogFileNotFoundDom = () => {
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: Message,
     tabIndex: 0,
     childCount: 1
@@ -2058,7 +2502,7 @@ const getErrorDom = (errorCode, error) => {
     return getLogFileNotFoundDom();
   }
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: Error$1,
     tabIndex: 0,
     childCount: 1
@@ -2067,7 +2511,7 @@ const getErrorDom = (errorCode, error) => {
 
 const getOutputVirtualDom = (lines, errorCode, error) => {
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: mergeClassNames(Viewlet, Output),
     childCount: 1
   }, ...getContentDom(lines, error), ...getErrorDom(errorCode, error)];
@@ -2131,14 +2575,14 @@ const getActionButtonVirtualDom = button => {
     icon
   } = button;
   return [{
-    type: VirtualDomElements.Button,
+    type: Button,
     className: IconButton,
     name: id,
     title: label,
     childCount: 1,
     onClick: HandleButtonClick
   }, {
-    type: VirtualDomElements.Div,
+    type: Div,
     className: mergeClassNames(MaskIcon, icon)
   }];
 };
@@ -2150,11 +2594,11 @@ const getActionButtonsVirtualDom = buttons => {
 const getFilterVirtualDom = () => {
   const placeholder = 'Filter';
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: Filter,
     childCount: 1
   }, {
-    type: VirtualDomElements.Input,
+    type: Input,
     className: mergeClassNames(InputBox, FilterInput),
     childCount: 0,
     placeholder,
@@ -2169,7 +2613,7 @@ const getOptionVirtualDom = option => {
     label
   } = option;
   return [{
-    type: VirtualDomElements.Option,
+    type: Option$1,
     className: Option,
     childCount: 1,
     value: id
@@ -2178,7 +2622,7 @@ const getOptionVirtualDom = option => {
 
 const getSelectVirtualDom = options => {
   return [{
-    type: VirtualDomElements.Select,
+    type: Select$1,
     className: Select,
     childCount: options.length,
     name: Output$1,
@@ -2194,9 +2638,9 @@ const getChildCount = buttonsLength => {
 const getActionsVirtualDom = (options, buttons) => {
   const childCount = getChildCount(buttons.length);
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: Actions,
-    role: AriaRoles.ToolBar,
+    role: ToolBar,
     childCount
   }, ...getFilterVirtualDom(), ...getSelectVirtualDom(options), ...getActionButtonsVirtualDom(buttons)];
 };
@@ -2244,9 +2688,29 @@ const resize = (state, dimensions) => {
   };
 };
 
+const serializeLinePart = part => {
+  return part.value;
+};
+const serializeLineParts = parts => {
+  return parts.map(serializeLinePart).join('');
+};
+const serializeLines = lines => {
+  return lines.map(serializeLineParts).join('\n');
+};
+
+// no local use of Line/LinePart here; serializeLines handles typing
+
 const saveOutputAs = async state => {
-  // TODO show open file picker
-  // TODO write to file
+  // @ts-ignore
+  const uri = await invoke$1('FilePicker.showSaveFilePicker');
+  if (!uri) {
+    return state;
+  }
+  const {
+    listItems
+  } = state;
+  const content = serializeLines(listItems);
+  await writeFile(uri, content);
   // TODO if error occurs, show error dialog
   return state;
 };
@@ -2306,7 +2770,7 @@ const commandMap = {
   'Output.renderActions': wrapGetter(renderActions),
   'Output.renderEventListeners': renderEventListeners,
   'Output.resize': resize,
-  'Output.saveOutputAs': wrapCommand(saveOutputAs),
+  'Output.saveAs': wrapCommand(saveOutputAs),
   'Output.saveState': wrapGetter(saveState),
   'Output.selectChannel': wrapCommand(selectChannel),
   'Output.setLogLevel': setLogLevel,
@@ -2317,6 +2781,7 @@ const commandMap = {
 const commandMapRef = {};
 
 const listen = async () => {
+  registerCommands(commandMap);
   Object.assign(commandMapRef, commandMap);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMapRef

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/output-view",
-  "version": "1.18.0",
+  "version": "2.0.0",
   "description": "Output View Worker",
   "repository": {
     "type": "git",