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

package/dist/fileSystemWorkerMain.js

@@ -828,7 +828,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 +848,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 +862,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}`);
@@ -1672,6 +1713,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 +1897,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 +1916,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 +1934,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 +1983,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 +2127,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.10.1",
   "description": "File System Worker",
   "keywords": [
     "Lvce Editor"