@lvce-editor/output-view 1.8.0 → 1.10.0

package/dist/outputViewWorkerMain.js

@@ -54,6 +54,49 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$1;
+    default:
+      return Unknown;
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -472,13 +515,13 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
+const set$5 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
 let id = 0;
@@ -491,7 +534,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$4(id, resolve);
+  set$5(id, resolve);
   return {
     id,
     promise
@@ -663,7 +706,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -836,7 +879,7 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke = (ipc, method, ...params) => {
+const invoke$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer = (ipc, method, ...params) => {
@@ -875,7 +918,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
+      return invoke$1(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer(ipc, method, ...params);
@@ -1061,14 +1104,16 @@ const Script = 2;
 
 const {
   get: get$1,
-  set: set$2,
+  set: set$4,
   wrapCommand,
   wrapGetter
 } = create$2();
 
-const create$1 = (id, uri, x, y, width, height, workspaceUri) => {
+const create$1 = (id, uri, x, y, width, height, platform, parentId) => {
+  number(parentId);
   const state = {
     uid: id,
+    parentId,
     uri,
     focusedIndex: -2,
     message: '',
@@ -1085,29 +1130,35 @@ const create$1 = (id, uri, x, y, width, height, workspaceUri) => {
     collapsedUris: [],
     selectedOption: '',
     smallWidthBreakPoint: 650,
-    workspaceUri,
+    workspaceUri: '',
     options: [],
     error: '',
     errorCode: 0,
     buttons: [],
-    filteredItems: []
+    filteredItems: [],
+    platform
   };
-  set$2(id, state, state);
+  set$4(id, state, state);
 };
 
-const isEqual$1 = (oldState, newState) => {
+const isEqual$2 = (oldState, newState) => {
   return newState.inputSource === User || oldState.filterValue === newState.filterValue;
 };
 
+const isEqual$1 = (oldState, newState) => {
+  return oldState.selectedOption === newState.selectedOption;
+};
+
 const isEqual = (oldState, newState) => {
-  return oldState.filterValue === newState.filterValue && oldState.message === newState.message && oldState.options === newState.options && oldState.listItems === newState.listItems;
+  return oldState.selectedOption === newState.selectedOption;
 };
 
 const RenderItems = 1;
 const RenderFilterValue = 2;
+const RenderSelectedItem = 3;
 
-const modules = [isEqual, isEqual$1];
-const numbers = [RenderItems, RenderFilterValue];
+const modules = [isEqual$1, isEqual$2, isEqual];
+const numbers = [RenderItems, RenderFilterValue, RenderSelectedItem];
 
 const diff = (oldState, newState) => {
   const diffResult = [];
@@ -1280,24 +1331,97 @@ const create = rpcId => {
     }
   };
 };
+const ExtensionHostWorker = 44;
 const RendererWorker$1 = 1;
 const FileSystemWorker$1 = 209;
+const {
+  invoke: invoke$9,
+  set: set$9} = create(ExtensionHostWorker);
+const ExtensionHost = {
+  __proto__: null,
+  invoke: invoke$9,
+  set: set$9
+};
 const {
   invoke: invoke$7,
-  set: set$7} = create(FileSystemWorker$1);
+  invokeAndTransfer: invokeAndTransfer$7,
+  set: set$7,
+  dispose: dispose$7
+} = create(FileSystemWorker$1);
+const remove = async dirent => {
+  return invoke$7('FileSystem.remove', dirent);
+};
+const readDirWithFileTypes = async uri => {
+  return invoke$7('FileSystem.readDirWithFileTypes', uri);
+};
+const getPathSeparator = async root => {
+  // @ts-ignore
+  return invoke$7('FileSystem.getPathSeparator', root);
+};
+const getRealPath = async path => {
+  return invoke$7('FileSystem.getRealPath', path);
+};
+const stat = async dirent => {
+  return invoke$7('FileSystem.stat', dirent);
+};
+const createFile = async uri => {
+  return invoke$7('FileSystem.writeFile', uri, '');
+};
 const readFile$1 = async uri => {
   return invoke$7('FileSystem.readFile', uri);
 };
 const writeFile$1 = async (uri, content) => {
   return invoke$7('FileSystem.writeFile', uri, content);
 };
+const mkdir = async uri => {
+  return invoke$7('FileSystem.mkdir', uri);
+};
+const rename = async (oldUri, newUri) => {
+  return invoke$7('FileSystem.rename', oldUri, newUri);
+};
+const copy = async (oldUri, newUri) => {
+  return invoke$7('FileSystem.copy', oldUri, newUri);
+};
+const exists = async uri => {
+  // @ts-ignore
+  return invoke$7('FileSystem.exists', uri);
+};
+const getFolderSize$1 = async uri => {
+  // @ts-ignore
+  return invoke$7('FileSystem.getFolderSize', uri);
+};
+const readFileAsBlob = async uri => {
+  // @ts-ignore
+  return invoke$7('FileSystem.readFileAsBlob', uri);
+};
+const appendFile = async (uri, text) => {
+  // @ts-ignore
+  return invoke$7('FileSystem.appendFile', uri, text);
+};
 const FileSystemWorker = {
   __proto__: null,
+  appendFile,
+  copy,
+  createFile,
+  dispose: dispose$7,
+  exists,
+  getFolderSize: getFolderSize$1,
+  getPathSeparator,
+  getRealPath,
+  invoke: invoke$7,
+  invokeAndTransfer: invokeAndTransfer$7,
+  mkdir,
+  readDirWithFileTypes,
   readFile: readFile$1,
+  readFileAsBlob,
+  remove,
+  rename,
   set: set$7,
+  stat,
   writeFile: writeFile$1
 };
 const {
+  invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$3,
   set: set$3} = create(RendererWorker$1);
 const sendMessagePortToFileSystemWorker$2 = async (port, rpcId) => {
@@ -1305,13 +1429,22 @@ const sendMessagePortToFileSystemWorker$2 = async (port, rpcId) => {
   // @ts-ignore
   await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
+const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const activateByEvent$1 = event => {
+  return invoke$3('ExtensionHostManagement.activateByEvent', event);
+};
 const RendererWorker = {
   __proto__: null,
+  activateByEvent: activateByEvent$1,
+  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$1,
   sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$2,
   set: set$3};
 
 const {
-  set: set$1,
+  set: set$2,
   readFile,
   writeFile
 } = FileSystemWorker;
@@ -1430,7 +1563,7 @@ const handleFilterInput = async (state, value) => {
   };
 };
 
-const handleSelect = async (state, id) => {
+const selectChannel = async (state, id) => {
   const {
     options
   } = state;
@@ -1446,15 +1579,48 @@ const handleSelect = async (state, id) => {
   } = await loadLines(matchingOption.uri);
   return {
     ...state,
-    listItems: lines,
     error,
-    errorCode: code
+    errorCode: code,
+    listItems: lines,
+    selectedOption: id
   };
 };
 
+const handleSelect = async (state, id) => {
+  return selectChannel(state, id);
+};
+
 const {
+  sendMessagePortToExtensionHostWorker,
   sendMessagePortToFileSystemWorker: sendMessagePortToFileSystemWorker$1,
-  set} = RendererWorker;
+  set: set$1,
+  activateByEvent
+} = RendererWorker;
+
+const sendMessagePortToExtensionHostWorker2 = async port => {
+  await sendMessagePortToExtensionHostWorker(port);
+};
+
+const createExtensionHostRpc = async () => {
+  try {
+    const rpc = await TransferMessagePortRpcParent.create({
+      commandMap: {},
+      send: sendMessagePortToExtensionHostWorker2
+    });
+    return rpc;
+  } catch (error) {
+    throw new VError(error, `Failed to create extension host rpc`);
+  }
+};
+
+const {
+  set,
+  invoke} = ExtensionHost;
+
+const initializeExtensionHost = async () => {
+  const extensionHostRpc = await createExtensionHostRpc();
+  set(extensionHostRpc);
+};
 
 const sendMessagePortToFileSystemWorker = async port => {
   await sendMessagePortToFileSystemWorker$1(port, 0);
@@ -1474,14 +1640,19 @@ const createFileSystemWorkerRpc = async () => {
 
 const initializeFileSystemWorker = async () => {
   const rpc = await createFileSystemWorkerRpc();
-  set$1(rpc);
+  set$2(rpc);
 };
 
 const initialize = async () => {
-  await initializeFileSystemWorker();
+  await Promise.all([initializeFileSystemWorker(), initializeExtensionHost()]);
 };
 
+const Web = 1;
+
 const getSelectedItem = platform => {
+  if (platform === Web) {
+    return '';
+  }
   return MainProcess;
 };
 
@@ -1501,7 +1672,30 @@ const loadButtons = () => {
   }];
 };
 
+const error = error => {
+  console.error(error);
+};
+
+const getExtensionOptions = async () => {
+  try {
+    // TODO make api more declarative:
+    // output channels are registered in extension manifest
+    // only downside: it might show channels for extensions that are not active
+    await activateByEvent('onOutput');
+    // @ts-ignore
+    const channels = await invoke('Output.getEnabledProviders');
+    return channels;
+  } catch (error$1) {
+    error(error$1);
+    return [];
+  }
+};
+
 const loadOptions = async platform => {
+  const extensionOptions = await getExtensionOptions();
+  if (platform === Web) {
+    return extensionOptions;
+  }
   return [{
     id: MainProcess,
     label: 'Main Process',
@@ -1510,7 +1704,29 @@ const loadOptions = async platform => {
     id: SharedProcess,
     label: 'Shared Process',
     uri: 'file:///tmp/log-shared-process.txt'
-  }];
+  }, ...extensionOptions];
+};
+
+const watchCallbacks = Object.create(null);
+const registerWatchCallback = (id, fn) => {
+  watchCallbacks[id] = fn;
+};
+const executeWatchCallBack = id => {
+  watchCallbacks[id]();
+};
+
+const setupChangeListener = async uri => {
+  try {
+    const watchId = Math.random();
+    registerWatchCallback(watchId, () => {
+      // TODO
+      // console.log('channel changed')
+    });
+    // @ts-ignore
+    await FileSystemWorker.invoke(/* OutputChannel.open */'FileSystem.watchFile', watchId, /* path */uri);
+  } catch {
+    // ignore
+  }
 };
 
 const isString = value => {
@@ -1522,19 +1738,29 @@ const getSavedCollapsedUris = savedState => {
   }
   return [];
 };
+const getMatchingOpen = (options, id) => {
+  return options.find(option => option.id === id) || options[0];
+};
 const loadContent = async (state, savedState) => {
+  const {
+    platform
+  } = state;
   const collapsedUris = getSavedCollapsedUris(savedState);
-  const selectedId = getSelectedItem();
-  const options = await loadOptions();
-  const uri = options.find(option => option.id === selectedId)?.uri;
-  if (!uri) {
+  const selectedId = getSelectedItem(platform);
+  const options = await loadOptions(platform);
+  const option = getMatchingOpen(options, selectedId);
+  if (!option) {
     throw new Error('option not found');
   }
+  const {
+    uri
+  } = option;
   const {
     lines,
     error,
     code
   } = await loadLines(uri);
+  await setupChangeListener(uri);
   const buttons = loadButtons();
   return {
     ...state,
@@ -1699,12 +1925,20 @@ const renderItems = (oldState, newState) => {
   return ['Viewlet.setDom2', dom];
 };
 
+const renderSelectedItem = (oldState, newState) => {
+  const value = newState.selectedOption;
+  const name = Output$2;
+  return ['Viewlet.setValueByName', newState.parentId, name, value];
+};
+
 const getRenderer = diffType => {
   switch (diffType) {
     case RenderItems:
       return renderItems;
     case RenderFilterValue:
       return renderFilterValue;
+    case RenderSelectedItem:
+      return renderSelectedItem;
     default:
       throw new Error('unknown renderer');
   }
@@ -1724,7 +1958,7 @@ const render2 = (uid, diffResult) => {
     oldState,
     newState
   } = get$1(uid);
-  set$2(uid, newState, newState);
+  set$4(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -1878,11 +2112,17 @@ const commandMap = {
   'Output.closeFindWidget': wrapCommand(closeFindWidget),
   'Output.create': create$1,
   'Output.diff2': diff2,
+  'Output.executeWatchCallback': executeWatchCallBack,
   'Output.focusIndex': wrapCommand(focusIndex),
+  'Output.getActions': getActions,
   'Output.getCommandIds': getCommandIds,
   'Output.getKeyBindings': getKeyBindings,
+  'Output.handleButtonClick': wrapCommand(handleButtonClick),
   'Output.handleData': wrapCommand(handleData),
   'Output.handleError': wrapCommand(handleError),
+  'Output.selectChannel': wrapCommand(selectChannel),
+  'Output.handleFilterInput': wrapCommand(handleFilterInput),
+  'Output.handleSelect': wrapCommand(handleSelect),
   'Output.initialize': initialize,
   'Output.loadContent2': wrapCommand(loadContent),
   'Output.openFindWidget': wrapCommand(openFindWidget),
@@ -1892,11 +2132,7 @@ const commandMap = {
   'Output.resize': resize,
   'Output.saveState': saveState,
   'Output.setOutputChannel': wrapCommand(setOutputChannel),
-  'Output.getActions': getActions,
-  'Output.terminate': terminate,
-  'Output.handleSelect': wrapCommand(handleSelect),
-  'Output.handleFilterInput': wrapCommand(handleFilterInput),
-  'Output.handleButtonClick': wrapCommand(handleButtonClick)
+  'Output.terminate': terminate
 };
 
 const listen = async () => {
@@ -1904,7 +2140,7 @@ const listen = async () => {
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMapRef
   });
-  set(rpc);
+  set$1(rpc);
 };
 
 const main = async () => {

package/package.json

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