@lvce-editor/output-view 1.1.0 → 1.3.0

package/dist/outputViewWorkerMain.js

@@ -940,6 +940,7 @@ const {
 const create$1 = (id, uri, x, y, width, height, workspaceUri) => {
   const state = {
     uid: id,
+    uri,
     focusedIndex: -2,
     message: '',
     itemHeight: 22,
@@ -953,8 +954,11 @@ const create$1 = (id, uri, x, y, width, height, workspaceUri) => {
     maxLineY: 0,
     listItems: [],
     collapsedUris: [],
+    selectedOption: '',
     smallWidthBreakPoint: 650,
-    workspaceUri
+    workspaceUri,
+    options: [],
+    error: ''
   };
   set$1(id, state, state);
 };
@@ -964,7 +968,7 @@ const isEqual$1 = (oldState, newState) => {
 };
 
 const isEqual = (oldState, newState) => {
-  return oldState.filterValue === newState.filterValue && oldState.message === newState.message;
+  return oldState.filterValue === newState.filterValue && oldState.message === newState.message && oldState.options === newState.options && oldState.listItems === newState.listItems;
 };
 
 const RenderItems = 1;
@@ -1037,14 +1041,25 @@ const KeyCode = {
   Space,
   UpArrow
 };
+const mergeClassNames = (...classNames) => {
+  return classNames.filter(Boolean).join(' ');
+};
 const Div = 4;
+const Text = 12;
 const VirtualDomElements = {
   __proto__: null,
   Div};
+const text = data => {
+  return {
+    type: Text,
+    text: data,
+    childCount: 0
+  };
+};
 
 const FocusProblems = 19;
 
-const getKeyBindings = () => {
+const getKeyBindings$1 = () => {
   return [{
     key: KeyCode.DownArrow,
     command: 'Problems.focusNext',
@@ -1108,6 +1123,391 @@ const handleError = async state => {
 
 const initialize = async () => {};
 
+const getSelectedItem = platform => {
+  return 'file:///tmp/log-main-process.txt';
+};
+
+const rpcs = Object.create(null);
+const set$g = (id, rpc) => {
+  rpcs[id] = rpc;
+};
+const get = id => {
+  return rpcs[id];
+};
+
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
+
+const create = rpcId => {
+  return {
+    // @ts-ignore
+    invoke(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invoke(method, ...params);
+    },
+    // @ts-ignore
+    invokeAndTransfer(method, ...params) {
+      const rpc = get(rpcId);
+      // @ts-ignore
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    set(rpc) {
+      set$g(rpcId, rpc);
+    },
+    async dispose() {
+      const rpc = get(rpcId);
+      await rpc.dispose();
+    }
+  };
+};
+const DebugWorker$1 = 55;
+const RendererWorker$1 = 1;
+const {
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$3,
+  set: set$3,
+  dispose: dispose$3
+} = create(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke$3('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke$3('FileSystemHandle.getFilePathElectron', file);
+};
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$3('ContextMenu.show', x, y, id, ...args);
+};
+const getElectronVersion = async () => {
+  return invoke$3('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke$3('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke$3(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke$3('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke$3('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke$3('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke$3('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke$3('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer$3('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke$3('WebView.unregisterInterceptor', id);
+};
+const sendMessagePortToEditorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+const sendMessagePortToErrorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = 'Markdown.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const readFile = async uri => {
+  return invoke$3('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke$3('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer$3('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke$3('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke$3('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke$3('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  return invoke$3('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke$3('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke$3('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke$3('IconTheme.getFolderIcon', options);
+};
+const closeWidget = async widgetId => {
+  return invoke$3('Viewlet.closeWidget', widgetId);
+};
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer$3('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const confirm = async (message, options) => {
+  // @ts-ignore
+  const result = await invoke$3('Confirmprompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened = async () => {
+  return invoke$3(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings = async () => {
+  return invoke$3('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$3('ClipBoard.writeText', /* text */text);
+};
+const writeClipBoardImage = async blob => {
+  // @ts-ignore
+  await invoke$3('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke$3('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke$3('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke$3('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke$3('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke$3('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke$3('IconTheme.getIcons', requests);
+  return icons;
+};
+const activateByEvent = event => {
+  return invoke$3('ExtensionHostManagement.activateByEvent', event);
+};
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke$3('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  // @ts-ignore
+  return invoke$3('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke$3('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker$1);
+};
+const getPreference = async key => {
+  return await invoke$3('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke$3('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke$3('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke$3('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke$3('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer$3(
+  // @ts-ignore
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+const handleDebugScriptParsed = async script => {
+  await invoke$3('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke$3('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke$3('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke$3('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke$3('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  // @ts-ignore
+  return await invoke$3('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke$3('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke$3('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke$3('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke$3('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke$3('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke$3('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke$3('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke$3('Extensions.handleInput', searchValue);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke$3('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke$3('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke$3('Preferences.getAll');
+};
+const RendererWorker = {
+  __proto__: null,
+  activateByEvent,
+  applyBulkReplacement,
+  closeWidget,
+  confirm,
+  disableExtension,
+  dispose: dispose$3,
+  enableExtension,
+  getActiveEditorId,
+  getAllExtensions,
+  getAllPreferences,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
+  getIcons,
+  getKeyBindings,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened,
+  getV8Version,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  installExtension,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$3,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
+  openUri,
+  openUrl,
+  openWidget,
+  readFile,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
+  sendMessagePortToEditorWorker,
+  sendMessagePortToErrorWorker,
+  sendMessagePortToExtensionHostWorker,
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSyntaxHighlightingWorker,
+  set: set$3,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showErrorDialog,
+  showMessageBox,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText
+};
+
+const loadLines = async uri => {
+  try {
+    // TODO use log stream, updating the output when the file is changed
+    const content = await RendererWorker.invoke('FileSystem.readFile', uri);
+    const lines = content.split('\n');
+    return {
+      error: '',
+      lines
+    };
+  } catch (error) {
+    return {
+      error: `${error}`,
+      lines: []
+    };
+  }
+};
+
 const isString = value => {
   return typeof value === 'string';
 };
@@ -1119,11 +1519,19 @@ const getSavedCollapsedUris = savedState => {
 };
 const loadContent = async (state, savedState) => {
   const collapsedUris = getSavedCollapsedUris(savedState);
+  const selectedUri = getSelectedItem();
+  const {
+    lines,
+    error
+  } = await loadLines(selectedUri);
   return {
     ...state,
     inputSource: Script,
-    listItems: [],
-    collapsedUris
+    listItems: lines,
+    collapsedUris,
+    options: [],
+    selectedOption: selectedUri,
+    error
   };
 };
 
@@ -1134,15 +1542,129 @@ const openFindWidget = async state => {
   };
 };
 
+const Button = 1;
+const Select = 2;
+
+const Blank = 'Blank';
+const ClearAll = 'ClearAll';
+
+const emptyObject = {};
+const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
+const i18nString = (key, placeholders = emptyObject) => {
+  if (placeholders === emptyObject) {
+    return key;
+  }
+  const replacer = (match, rest) => {
+    return placeholders[rest];
+  };
+  return key.replaceAll(RE_PLACEHOLDER, replacer);
+};
+
+/**
+ * @enum {string}
+ */
+const UiStrings = {
+  Output: 'output',
+  ClearOutput: 'clear output',
+  TurnOffAutoScroll: 'Turn auto scrolling off',
+  OpenLogFile: 'open output log file'
+};
+const output = () => {
+  return i18nString(UiStrings.Output);
+};
+const clearOutput = () => {
+  return i18nString(UiStrings.ClearOutput);
+};
+const turnOffAutoScroll = () => {
+  return i18nString(UiStrings.TurnOffAutoScroll);
+};
+const openLogFile = () => {
+  return i18nString(UiStrings.OpenLogFile);
+};
+
+const toSelectOption = option => {
+  return option.name;
+};
+const toSelectOptions = options => {
+  return options.map(toSelectOption);
+};
+const getActions = state => {
+  const {
+    options
+  } = state;
+  return [{
+    type: Select,
+    id: output(),
+    options: toSelectOptions(options)
+  }, {
+    type: Button,
+    id: clearOutput(),
+    icon: ClearAll
+  }, {
+    type: Button,
+    id: turnOffAutoScroll(),
+    icon: Blank
+  }, {
+    type: Button,
+    id: openLogFile(),
+    icon: Blank
+  }];
+};
+
 const Filter = 'filter';
 
 const renderFilterValue = (oldState, newState) => {
   return ['Viewlet.setValueByName', Filter, newState.filterValue];
 };
 
+const Actions = 'Actions';
+const Viewlet = 'Viewlet';
+const Output = 'Output';
+
+const parentNode = {
+  type: VirtualDomElements.Div,
+  className: 'Line',
+  childCount: 1
+};
+const getLineDom = line => {
+  return [parentNode, text(line)];
+};
+
+const getContentDom = (lines, error) => {
+  if (error) {
+    return [];
+  }
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'OutputContent',
+    role: 'log',
+    tabIndex: 0,
+    childCount: lines.length
+  }, ...lines.flatMap(getLineDom)];
+};
+
+const getErrorDom = error => {
+  if (!error) {
+    return [];
+  }
+  return [{
+    type: VirtualDomElements.Div,
+    className: 'Error',
+    tabIndex: 0,
+    childCount: 1
+  }, text(error)];
+};
+
+const getOutputVirtualDom = (lines, error) => {
+  return [{
+    type: VirtualDomElements.Div,
+    className: mergeClassNames(Viewlet, Output),
+    childCount: 1
+  }, ...getContentDom(lines, error), ...getErrorDom(error)];
+};
+
 const renderItems = (oldState, newState) => {
-  // TODO
-  const dom = [];
+  const dom = getOutputVirtualDom(newState.listItems, newState.error);
   return ['Viewlet.setDom2', dom];
 };
 
@@ -1176,8 +1698,6 @@ const render2 = (uid, diffResult) => {
   return commands;
 };
 
-const Actions = 'Actions';
-
 const getActionsVirtualDom = actions => {
   return [{
     type: VirtualDomElements.Div,
@@ -1251,11 +1771,11 @@ const commandMap = {
   'Output.diff2': diff2,
   'Output.focusIndex': wrapCommand(focusIndex),
   'Output.getCommandIds': getCommandIds,
-  'Output.getKeyBindings': getKeyBindings,
+  'Output.getKeyBindings': getKeyBindings$1,
   'Output.handleData': handleData,
   'Output.handleError': handleError,
   'Output.initialize': initialize,
-  'Output.loadContent': wrapCommand(loadContent),
+  'Output.loadContent2': wrapCommand(loadContent),
   'Output.openFindWidget': openFindWidget,
   'Output.render2': render2,
   'Output.renderActions': renderActions,
@@ -1263,49 +1783,10 @@ const commandMap = {
   'Output.resize': resize,
   'Output.saveState': saveState,
   'Output.setOutputChannel': setOutputChannel,
+  'Output.getActions': getActions,
   'Output.terminate': terminate
 };
 
-const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
-  rpcs[id] = rpc;
-};
-const get = id => {
-  return rpcs[id];
-};
-
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
-const create = rpcId => {
-  return {
-    // @ts-ignore
-    invoke(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invoke(method, ...params);
-    },
-    // @ts-ignore
-    invokeAndTransfer(method, ...params) {
-      const rpc = get(rpcId);
-      // @ts-ignore
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    set(rpc) {
-      set$g(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get(rpcId);
-      await rpc.dispose();
-    }
-  };
-};
-const RendererWorker$1 = 1;
-const {
-  set: set$3} = create(RendererWorker$1);
-const RendererWorker = {
-  __proto__: null,
-  set: set$3};
-
 const {
   set} = RendererWorker;
 

package/package.json

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