@lvce-editor/file-system-worker 5.10.0 → 5.11.0

package/dist/fileSystemWorkerMain.js

@@ -324,7 +324,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -478,7 +477,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -828,7 +834,10 @@ const constructError = (message, type, name) => {
   if (ErrorConstructor === Error) {
     const error = new Error(message);
     if (name && name !== 'VError') {
-      error.name = name;
+      Object.defineProperty(error, 'name', {
+        configurable: true,
+        value: name
+      });
     }
     return error;
   }
@@ -845,8 +854,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -857,55 +868,91 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
+    }
+  }
+  Object.defineProperty(error, 'stack', {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
+};
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    setStack(error, `${error.stack}${NewLine}${currentStack}`);
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
+    return;
+  }
+  if (error.data.stack) {
+    setStack(restoredError, error.data.stack);
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
+  }
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
-    return restoredError;
+    return restoreMethodNotFoundError(error, currentStack);
   }
   if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -1312,28 +1359,72 @@ const create$3 = async ({
 }) => {
   // TODO create a commandMap per rpc instance
   register$1(commandMap);
-  const rawIpc = await IpcParentWithWebSocket$1.create({
-    webSocket
-  });
+  let rawIpc;
+  try {
+    rawIpc = await IpcParentWithWebSocket$1.create({
+      webSocket
+    });
+  } catch (error) {
+    throw new VError(error, 'Failed to create rpc connection');
+  }
   const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
 
+const reconnectDelay = 2000;
+const waitForReconnect = async () => {
+  await new Promise(resolve => {
+    setTimeout(resolve, reconnectDelay);
+  });
+};
+const connect = async ({
+  commandMap,
+  wsUrl
+}) => {
+  const webSocket = new WebSocket(wsUrl);
+  try {
+    const rpc = await create$3({
+      commandMap,
+      webSocket
+    });
+    return {
+      rpc,
+      webSocket
+    };
+  } catch (error) {
+    webSocket.close();
+    throw error;
+  }
+};
 const create$2 = async ({
   commandMap,
+  onClose,
   type
 }) => {
   const host = getHost();
   const protocol = getProtocol();
   const wsUrl = getWebSocketUrl(type, host, protocol);
-  const webSocket = new WebSocket(wsUrl);
-  const rpc = await create$3({
-    commandMap,
-    webSocket
-  });
-  return rpc;
+  let connection;
+  try {
+    connection = await connect({
+      commandMap,
+      wsUrl
+    });
+  } catch {
+    await waitForReconnect();
+    connection = await connect({
+      commandMap,
+      wsUrl
+    });
+  }
+  if (onClose) {
+    connection.webSocket.addEventListener('close', onClose, {
+      once: true
+    });
+  }
+  return connection.rpc;
 };
 
 const create$1 = async ({
@@ -1672,6 +1763,7 @@ const Http = 'http:';
 const Memory = 'memfs:';
 const Https = 'https:';
 const File$2 = 'file:';
+const Fetch$1 = 'fetch:';
 
 const watchCallbacks = Object.create(null);
 const registerWatchCallback = (id, rpcId, commandId, uri) => {
@@ -1855,6 +1947,10 @@ const FileSystemMemory = {
    writeFile: writeFile$1
 };
 
+const isFetch = uri => {
+  return uri.startsWith(Fetch$1);
+};
+
 const isHttp = uri => {
   return uri.startsWith(Http) || uri.startsWith(Https);
 };
@@ -1870,6 +1966,9 @@ const remove = async dirent => {
   return remove$2(dirent);
 };
 const readFile = async uri => {
+  if (isFetch(uri)) {
+    return invoke$2('FileSystem.readFile', uri);
+  }
   if (isHttp(uri)) {
     return readFile$3(uri);
   }
@@ -1885,6 +1984,9 @@ const appendFile = async (uri, text) => {
   return appendFile$1(uri, text);
 };
 const readDirWithFileTypes = async uri => {
+  if (isFetch(uri)) {
+    return invoke$2('FileSystem.readDirWithFileTypes', uri);
+  }
   if (isMemory(uri)) {
     return invoke$2('FileSystem.readDirWithFileTypes', uri);
   }
@@ -1931,6 +2033,9 @@ const stat = async dirent => {
   return stat$2(dirent);
 };
 const exists = async uri => {
+  if (isFetch(uri)) {
+    return invoke$2('FileSystem.exists', uri);
+  }
   if (isHttp(uri)) {
     return exists$3(uri);
   }
@@ -2072,8 +2177,25 @@ const createFileSystemProcessRpc = async platform => {
   return create();
 };
 
+const throwUnavailableError = () => {
+  throw new Error('Disk file system is not available in web');
+};
+const createUnavailableFileSystemProcessRpc = () => {
+  return {
+    dispose: async () => {},
+    invoke: async () => {
+      return throwUnavailableError();
+    },
+    invokeAndTransfer: async () => {
+      return throwUnavailableError();
+    },
+    send: throwUnavailableError
+  };
+};
+
 const initializeFileSystemProcess = async platform => {
   if (platform === Web) {
+    set(createUnavailableFileSystemProcessRpc());
     return;
   }
   const rpc = await createFileSystemProcessRpc(platform);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/file-system-worker",
-  "version": "5.10.0",
+  "version": "5.11.0",
   "description": "File System Worker",
   "keywords": [
     "Lvce Editor"