@lvce-editor/static-server 0.57.0 → 0.57.2

package/static/{8f6701c → 4255ff7}/packages/extension-host-worker/dist/extensionHostWorkerMain.js

@@ -1113,7 +1113,7 @@ const rename$1 = async (protocol, oldUri, newUri) => {
     throw new VError(error, 'Failed to execute file system provider');
   }
 };
-const writeFile$2 = async (protocol, uri, content) => {
+const writeFile$3 = async (protocol, uri, content) => {
   try {
     const provider = get$a(protocol);
     return await provider.writeFile(uri, content);
@@ -1749,11 +1749,11 @@ const remove$3 = id => {
   delete callbacks[id];
 };
 let id$1 = 0;
-const create$3$1 = () => {
+const create$3$2 = () => {
   return ++id$1;
 };
 const registerPromise = () => {
-  const id = create$3$1();
+  const id = create$3$2();
   const {
     resolve,
     promise
@@ -1838,7 +1838,8 @@ const splitLines$1 = lines => {
   return lines.split(NewLine$1);
 };
 const getCurrentStack = () => {
-  const currentStack = joinLines(splitLines$1(new Error().stack || '').slice(2));
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines$1(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
 const getNewLineIndex = (string, startIndex = undefined) => {
@@ -2098,7 +2099,7 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const responseMessage = await promise;
   return unwrapJsonRpcResult(responseMessage);
 };
-const send = (transport, method, ...params) => {
+const send$1 = (transport, method, ...params) => {
   const message = create$4$2(method, params);
   transport.send(message);
 };
@@ -2109,6 +2110,12 @@ const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
 const commands = Object.create(null);
 const register$1 = commandMap => {
   Object.assign(commands, commandMap);
@@ -2119,7 +2126,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -2132,7 +2139,7 @@ const createRpc$1 = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
+      send$1(ipc, method, ...params);
     },
     invoke(method, ...params) {
       return invoke$1(ipc, method, ...params);
@@ -2176,7 +2183,7 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$e = async ({
+const create$f = async ({
   commandMap,
   messagePort
 }) => {
@@ -2191,9 +2198,9 @@ const create$e = async ({
 };
 const MessagePortRpcClient = {
   __proto__: null,
-  create: create$e
+  create: create$f
 };
-const create$d = async ({
+const create$e = async ({
   commandMap,
   messagePort,
   isMessagePortOpen
@@ -2211,7 +2218,7 @@ const create$d = async ({
 };
 const MessagePortRpcParent = {
   __proto__: null,
-  create: create$d
+  create: create$e
 };
 const create$5$1 = async ({
   commandMap,
@@ -2242,6 +2249,24 @@ const PlainMessagePortRpcParent = {
   __proto__: null,
   create: create$4$1
 };
+const create$3$1 = async ({
+  commandMap,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5$1({
+    commandMap,
+    messagePort: port2
+  });
+};
+const TransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$3$1
+};
 const create$2$1 = async ({
   commandMap,
   webSocket
@@ -2492,6 +2517,84 @@ const createNodeRpc = async ({
   }
 };
 
+const send = async port => {
+  const initialCommand = 'FileSystem.handleMessagePort';
+  await invokeAndTransfer$2('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, initialCommand);
+};
+const launchFileSystemProcess = async () => {
+  const rpc = await TransferMessagePortRpcParent.create({
+    commandMap: {},
+    send
+  });
+  return rpc;
+};
+
+let fileSystemWorkerPromise;
+const getOrCreateRpc$1 = async () => {
+  if (!fileSystemWorkerPromise) {
+    fileSystemWorkerPromise = launchFileSystemProcess();
+  }
+  return fileSystemWorkerPromise;
+};
+const append = async (uri, content) => {
+  const rpc = await getOrCreateRpc$1();
+  await rpc.invoke('FileSystem.appendFile', uri, content);
+};
+const writeFile$2 = async (uri, content) => {
+  const rpc = await getOrCreateRpc$1();
+  await rpc.invoke('FileSystem.writeFile', uri, content);
+};
+
+const getOutputFilePath = id => {
+  const outputFolderPath = 'file:///tmp';
+  const uri = `${outputFolderPath}/${id}.txt`;
+  return uri;
+};
+
+const providers = Object.create(null);
+const registerOutputChannel = provider => {
+  if (!provider) {
+    throw new Error(`provider is required`);
+  }
+  if (!provider.id) {
+    throw new Error('provider.id is required');
+  }
+  if (!provider.label) {
+    throw new Error('provider.label is required');
+  }
+  const uri = getOutputFilePath(provider.id);
+  providers[provider.id] = {
+    ...provider,
+    uri
+  };
+  let isFirst = true;
+  return {
+    async append(text) {
+      // TODO race condition?
+      if (isFirst) {
+        isFirst = false;
+        await writeFile$2(uri, '');
+      }
+      await append(uri, text + '\n');
+    },
+    getUri() {
+      return uri;
+    }
+  };
+};
+const getEnabledProviders = () => {
+  const values = Object.values(providers);
+  const enabledProviders = [];
+  for (const provider of values) {
+    enabledProviders.push({
+      id: provider.id,
+      label: provider.label,
+      uri: provider.uri
+    });
+  }
+  return enabledProviders;
+};
+
 const confirm = message => {
   string(message);
   const result = invoke$2('ConfirmPrompt.prompt', message);
@@ -2566,7 +2669,7 @@ const {
 });
 
 const getExtensionHostSubWorkerUrl = () => {
-  return '/8f6701c/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
+  return '/4255ff7/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
 };
 const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
@@ -3124,6 +3227,8 @@ const api = {
   // Implementation
   registerImplementationProvider: registerImplementationProvider,
   executeImplementationProvider: executeImplementationProvider,
+  // Output
+  registerOutputChannel: registerOutputChannel,
   // Prompt
   confirm: confirm,
   // QuickPick
@@ -3283,6 +3388,22 @@ const getExtensionId = extension => {
   return '<unknown>';
 };
 
+const isImportErrorChrome = error => {
+  return error && error instanceof Error && error.message.startsWith('Failed to fetch dynamically imported module');
+};
+
+const isImportErrorFirefox = error => {
+  return error && error instanceof TypeError && error.message === 'error loading dynamically imported module';
+};
+
+const isSyntaxError = error => {
+  return error instanceof SyntaxError;
+};
+
+const isImportError = error => {
+  return isImportErrorChrome(error) || isImportErrorFirefox(error) || isSyntaxError(error);
+};
+
 const states = Object.create(null);
 const set$5 = status => {
   states[status.id] = status;
@@ -3312,108 +3433,6 @@ const sleep = duration => {
   return promise;
 };
 
-// TODO make activation timeout configurable or remove it.
-// some extension might do workspace indexing which could take some time
-const activationTimeout$1 = 10_000;
-const rejectAfterTimeout$1 = async (timeout, token) => {
-  await sleep(timeout);
-  if (isCanceled(token)) {
-    return;
-  }
-  throw new Error(`Activation timeout of ${timeout}ms exceeded`);
-};
-
-// TODO separate importing extension and activating extension for smaller functions
-// and better error handling
-const activateExtension2 = async (extensionId, extension) => {
-  const token = create$1();
-  try {
-    const startTime = performance.now();
-    update(extensionId, {
-      status: Activating,
-      activationStartTime: startTime
-    });
-    const module = acquire(extensionId);
-    await Promise.race([module.activate(extension), rejectAfterTimeout$1(activationTimeout$1, token)]);
-    const endTime = performance.now();
-    const time = endTime - startTime;
-    update(extensionId, {
-      status: Activated,
-      activationTime: time,
-      activationEndTime: endTime
-    });
-  } catch (error) {
-    update(extensionId, {
-      status: Error$1 // TODO maybe store error also in runtime status state
-    });
-    const id = getExtensionId(extension);
-    throw new VError(error, `Failed to activate extension ${id}`);
-  } finally {
-    cancel(token);
-  }
-};
-
-const getUrlPrefix = (platform, extensionPath) => {
-  if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
-    return extensionPath;
-  }
-  if (platform === Web) {
-    return extensionPath;
-  }
-  if (extensionPath.startsWith('/')) {
-    return `/remote${extensionPath}`;
-  }
-  return `/remote/${extensionPath}`;
-};
-
-const handleRpcInfos = (extension, platform) => {
-  try {
-    if (!extension) {
-      return;
-    }
-    const rpcs = extension.rpc;
-    const urlPrefix = getUrlPrefix(platform, extension.path);
-    if (!rpcs) {
-      return;
-    }
-    if (!Array.isArray(rpcs)) {
-      return;
-    }
-    for (const rpc of rpcs) {
-      rpc.url = `${urlPrefix}/${rpc.url}`;
-      add$1(rpc.id, rpc);
-    }
-  } catch (error) {
-    console.warn(`Failed to handle extension rpcs: ${error}`);
-  }
-};
-
-class ContentSecurityPolicyError extends Error {
-  constructor(violatedDirective, sourceFile, lineNumber, columnNumber) {
-    super(`Content Security Policy Violation: ${violatedDirective}`);
-    this.name = 'ContentSecurityPolicyError';
-    this.stack = sourceFile ? `Content Security Policy Violation
-    at ${sourceFile}:${lineNumber}:${columnNumber}` : `Content Security Policy Violation
-    at <unknown>`;
-  }
-}
-
-const isImportErrorChrome = error => {
-  return error && error instanceof Error && error.message.startsWith('Failed to fetch dynamically imported module');
-};
-
-const isImportErrorFirefox = error => {
-  return error && error instanceof TypeError && error.message === 'error loading dynamically imported module';
-};
-
-const isSyntaxError = error => {
-  return error instanceof SyntaxError;
-};
-
-const isImportError = error => {
-  return isImportErrorChrome(error) || isImportErrorFirefox(error) || isSyntaxError(error);
-};
-
 const NotFound = 404;
 
 const RE_LINE_COLUMN = /(.*)(?:\(\d+:\d+\))/;
@@ -3442,9 +3461,9 @@ class BabelParseError extends SyntaxError {
 
 const getAssetDir = () => {
   // @ts-ignore
-  if (typeof '/8f6701c' !== 'undefined') {
+  if (typeof '/4255ff7' !== 'undefined') {
     // @ts-ignore
-    return '/8f6701c';
+    return '/4255ff7';
   }
   if (platform === Electron) {
     return '../../../../..';
@@ -3465,6 +3484,16 @@ const parse = async (code, options) => {
 
 const Module = 'module';
 
+class ContentSecurityPolicyError extends Error {
+  constructor(violatedDirective, sourceFile, lineNumber, columnNumber) {
+    super(`Content Security Policy Violation: ${violatedDirective}`);
+    this.name = 'ContentSecurityPolicyError';
+    this.stack = sourceFile ? `Content Security Policy Violation
+    at ${sourceFile}:${lineNumber}:${columnNumber}` : `Content Security Policy Violation
+    at <unknown>`;
+  }
+}
+
 const getLineAndColumn = (text, start, end) => {
   let index = -1;
   let line = 0;
@@ -3722,6 +3751,83 @@ const tryToGetActualImportErrorMessage = async (url, error) => {
   }
 };
 
+// TODO make activation timeout configurable or remove it.
+// some extension might do workspace indexing which could take some time
+const activationTimeout$1 = 10_000;
+const rejectAfterTimeout$1 = async (timeout, token) => {
+  await sleep(timeout);
+  if (isCanceled(token)) {
+    return;
+  }
+  throw new Error(`Activation timeout of ${timeout}ms exceeded`);
+};
+const activateExtension2 = async (extensionId, extension, absolutePath) => {
+  const token = create$1();
+  try {
+    const startTime = performance.now();
+    update(extensionId, {
+      status: Activating,
+      activationStartTime: startTime
+    });
+    const module = acquire(extensionId);
+    await Promise.race([module.activate(extension), rejectAfterTimeout$1(activationTimeout$1, token)]);
+    const endTime = performance.now();
+    const time = endTime - startTime;
+    update(extensionId, {
+      status: Activated,
+      activationTime: time,
+      activationEndTime: endTime
+    });
+  } catch (error) {
+    const id = getExtensionId(extension);
+    if (isImportError(error)) {
+      const actualErrorMessage = await tryToGetActualImportErrorMessage(absolutePath, error);
+      throw new Error(`Failed to activate extension ${id}: ${actualErrorMessage}`);
+    }
+    update(extensionId, {
+      status: Error$1 // TODO maybe store error also in runtime status state
+    });
+    throw new VError(error, `Failed to activate extension ${id}`);
+  } finally {
+    cancel(token);
+  }
+};
+
+const getUrlPrefix = (platform, extensionPath) => {
+  if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
+    return extensionPath;
+  }
+  if (platform === Web) {
+    return extensionPath;
+  }
+  if (extensionPath.startsWith('/')) {
+    return `/remote${extensionPath}`;
+  }
+  return `/remote/${extensionPath}`;
+};
+
+const handleRpcInfos = (extension, platform) => {
+  try {
+    if (!extension) {
+      return;
+    }
+    const rpcs = extension.rpc;
+    const urlPrefix = getUrlPrefix(platform, extension.path);
+    if (!rpcs) {
+      return;
+    }
+    if (!Array.isArray(rpcs)) {
+      return;
+    }
+    for (const rpc of rpcs) {
+      rpc.url = `${urlPrefix}/${rpc.url}`;
+      add$1(rpc.id, rpc);
+    }
+  } catch (error) {
+    console.warn(`Failed to handle extension rpcs: ${error}`);
+  }
+};
+
 const importScript = async url => {
   try {
     return await import(url);
@@ -5948,6 +6054,7 @@ const commandMap = {
   'IndexedDb.saveValue': saveValue,
   'IndexedDb.set': set$3,
   'Languages.getLanguages': getLanguages,
+  'Output.getEnabledProviders': getEnabledProviders,
   'SaveState.saveState': saveState,
   'SearchFileWithFetch.searchFileWithFetch': searchFile$2,
   'SearchFileWithHtml.searchFileWithHtml': searchFile$1,
@@ -5975,7 +6082,7 @@ const commandMap = {
   [FileSystemReadDirWithFileTypes]: readDirWithFileTypes$2,
   [FileSystemReadFile]: readFile$2,
   [FileSystemRename]: rename$1,
-  [FileSystemWriteFile]: writeFile$2,
+  [FileSystemWriteFile]: writeFile$3,
   [FormattingExecuteFormmattingProvider]: executeFormattingProvider,
   [HoverExecute]: executeHoverProvider,
   [ImplementationExecuteImplementationProvider]: executeImplementationProvider,

package/static/{8f6701c → 4255ff7}/packages/file-system-worker/dist/fileSystemWorkerMain.js

@@ -634,7 +634,8 @@ const splitLines = lines => {
   return lines.split(NewLine);
 };
 const getCurrentStack = () => {
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(2));
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
 const getNewLineIndex = (string, startIndex = undefined) => {
@@ -898,13 +899,19 @@ 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$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
 const commands = Object.create(null);
 const register = commandMap => {
   Object.assign(commands, commandMap);
@@ -915,7 +922,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -931,7 +938,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$1(ipc, method, ...params);
@@ -1140,6 +1147,10 @@ const remove$1$1 = async uri => {
 const readFile$2 = async uri => {
   return invoke$8('FileSystem.readFile', uri);
 };
+const appendFile$1$1 = async (uri, text) => {
+  // @ts-ignore
+  return invoke$8('FileSystem.appendFile', uri, text);
+};
 const readDirWithFileTypes$1$1 = async uri => {
   return invoke$8('FileSystem.readDirWithFileTypes', uri);
 };
@@ -1185,11 +1196,13 @@ const exists$1$1 = async uri => {
 };
 const FileSystemProcess = {
   __proto__: null,
+  appendFile: appendFile$1$1,
   copy: copy$1$1,
   exists: exists$1$1,
   getFolderSize: getFolderSize$2,
   getPathSeparator: getPathSeparator$1$1,
   getRealPath: getRealPath$1$1,
+  invoke: invoke$8,
   mkdir: mkdir$1$1,
   readDirWithFileTypes: readDirWithFileTypes$1$1,
   readFile: readFile$2,
@@ -1213,6 +1226,7 @@ const {
   rename: rename$1,
   copy: copy$1,
   mkdir: mkdir$1,
+  invoke,
   getFolderSize: getFolderSize$1,
   writeFile: writeFile$1,
   stat: stat$1,
@@ -1222,7 +1236,8 @@ const {
   readDirWithFileTypes: readDirWithFileTypes$1,
   readFile: readFile$1,
   remove: remove$1,
-  exists: exists$1
+  exists: exists$1,
+  appendFile: appendFile$1
 } = FileSystemProcess;
 
 const Http = 'http:';
@@ -1240,6 +1255,9 @@ const readFile = async uri => {
   }
   return readFile$1(uri);
 };
+const appendFile = async (uri, text) => {
+  return appendFile$1(uri, text);
+};
 const readDirWithFileTypes = async uri => {
   return readDirWithFileTypes$1(uri);
 };
@@ -1296,11 +1314,50 @@ const getFolderSize = async uri => {
   return getFolderSize$1(uri);
 };
 
+const watchCallbacks = Object.create(null);
+const registerWatchCallback = (id, fn) => {
+  watchCallbacks[id] = fn;
+};
+const executeWatchCallBack = async id => {
+  await watchCallbacks[id]();
+};
+const unregisterWatchCallback = id => {
+  delete watchCallbacks[id];
+};
+
+const watchFile = async (id, uri, rpcId) => {
+  const commandId = 'Output.executeWatchCallback';
+  registerWatchCallback(id, async () => {
+    const rpc = get(rpcId);
+    if (!rpc) {
+      return;
+    }
+    await rpc.invoke(commandId, id);
+  });
+  // @ts-ignore
+  await invoke('FileSystem.watchFile', id, uri);
+};
+const executeWatchCallback = async id => {
+  try {
+    await executeWatchCallBack(id);
+  } catch (error) {
+    console.error(error);
+  }
+};
+const unwatchFile = async id => {
+  unregisterWatchCallback(id);
+  // @ts-ignore
+  await invoke('FileSystem.unwatchFile', id);
+};
+
 const handleMessagePort = async (port, rpcId) => {
-  await PlainMessagePortRpc.create({
+  const rpc = await PlainMessagePortRpc.create({
     commandMap: {},
     messagePort: port
   });
+  if (rpcId) {
+    set$g(rpcId, rpc);
+  }
 };
 
 const getPortTuple = () => {
@@ -1340,11 +1397,13 @@ const createFileSystemProcessRpcElectron = async () => {
   }
 };
 
+const commandMapRef = {};
+
 const createFileSystemProcessRpcNode = async () => {
   try {
     const rpc = await WebSocketRpcParent2.create({
       type: 'file-system-process',
-      commandMap: {}
+      commandMap: commandMapRef
     });
     return rpc;
   } catch (error) {
@@ -1385,26 +1444,31 @@ const initialize = async platform => {
 };
 
 const commandMap = {
+  'FileSystem.appendFile': appendFile,
   'FileSystem.copy': copy,
   'FileSystem.createFile': createFile,
+  'FileSystem.executeWatchCallback': executeWatchCallback,
   'FileSystem.exists': exists,
   'FileSystem.getFolderSize': getFolderSize,
   'FileSystem.getPathSeparator': getPathSeparator,
   'FileSystem.getRealPath': getRealPath,
+  'FileSystem.handleMessagePort': handleMessagePort,
   'FileSystem.mkdir': mkdir,
   'FileSystem.readDirWithFileTypes': readDirWithFileTypes,
   'FileSystem.readFile': readFile,
+  'FileSystem.readFileAsBlob': readFileAsBlob,
   'FileSystem.readJson': readJson,
   'FileSystem.remove': remove,
   'FileSystem.rename': rename,
   'FileSystem.stat': stat,
+  'FileSystem.unwatchFile': unwatchFile,
+  'FileSystem.watchFile': watchFile,
   'FileSystem.writeFile': writeFile,
-  'FileSystem.handleMessagePort': handleMessagePort,
-  'FileSystem.readFileAsBlob': readFileAsBlob,
   'Initialize.initialize': initialize
 };
 
 const listen = async () => {
+  Object.assign(commandMapRef, commandMap);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });