@lvce-editor/file-system-worker 5.20.0 → 5.20.2

package/dist/fileSystemWorkerMain.js

@@ -1,160 +1,3 @@
-// TODO: including these in blob-util.ts causes typedoc to generate docs for them,
-// even with --excludePrivate ¯\_(ツ)_/¯
-/** @private */
-
-/* global Promise, Image, Blob, FileReader, atob, btoa,
-   BlobBuilder, MSBlobBuilder, MozBlobBuilder, WebKitBlobBuilder, webkitURL */
-/**
- * Shim for
- * [`new Blob()`](https://developer.mozilla.org/en-US/docs/Web/API/Blob.Blob)
- * to support
- * [older browsers that use the deprecated `BlobBuilder` API](http://caniuse.com/blob).
- *
- * Example:
- *
- * ```js
- * var myBlob = blobUtil.createBlob(['hello world'], {type: 'text/plain'});
- * ```
- *
- * @param parts - content of the Blob
- * @param properties - usually `{type: myContentType}`,
- *                           you can also pass a string for the content type
- * @returns Blob
- */
-function createBlob(parts, properties) {
-  parts = parts || [];
-  properties = properties || {};
-  if (typeof properties === 'string') {
-    properties = {
-      type: properties
-    }; // infer content type
-  }
-  try {
-    return new Blob(parts, properties);
-  } catch (e) {
-    if (e.name !== 'TypeError') {
-      throw e;
-    }
-    var Builder = typeof BlobBuilder !== 'undefined' ? BlobBuilder : typeof MSBlobBuilder !== 'undefined' ? MSBlobBuilder : typeof MozBlobBuilder !== 'undefined' ? MozBlobBuilder : WebKitBlobBuilder;
-    var builder = new Builder();
-    for (var i = 0; i < parts.length; i += 1) {
-      builder.append(parts[i]);
-    }
-    return builder.getBlob(properties.type);
-  }
-}
-/**
- * Convert a `Blob` to a binary string.
- *
- * Example:
- *
- * ```js
- * blobUtil.blobToBinaryString(blob).then(function (binaryString) {
- *   // success
- * }).catch(function (err) {
- *   // error
- * });
- * ```
- *
- * @param blob
- * @returns Promise that resolves with the binary string
- */
-function blobToBinaryString$1(blob) {
-  return new Promise(function (resolve, reject) {
-    var reader = new FileReader();
-    var hasBinaryString = typeof reader.readAsBinaryString === 'function';
-    reader.onloadend = function () {
-      var result = reader.result || '';
-      if (hasBinaryString) {
-        return resolve(result);
-      }
-      resolve(arrayBufferToBinaryString(result));
-    };
-    reader.onerror = reject;
-    if (hasBinaryString) {
-      reader.readAsBinaryString(blob);
-    } else {
-      reader.readAsArrayBuffer(blob);
-    }
-  });
-}
-/**
- * Convert a base64-encoded string to a `Blob`.
- *
- * Example:
- *
- * ```js
- * var blob = blobUtil.base64StringToBlob(base64String);
- * ```
- * @param base64 - base64-encoded string
- * @param type - the content type (optional)
- * @returns Blob
- */
-function base64StringToBlob(base64, type) {
-  var parts = [binaryStringToArrayBuffer(atob(base64))];
-  return type ? createBlob(parts, {
-    type: type
-  }) : createBlob(parts);
-}
-/**
- * Convert a binary string to a `Blob`.
- *
- * Example:
- *
- * ```js
- * var blob = blobUtil.binaryStringToBlob(binaryString);
- * ```
- *
- * @param binary - binary string
- * @param type - the content type (optional)
- * @returns Blob
- */
-function binaryStringToBlob$1(binary, type) {
-  return base64StringToBlob(btoa(binary), type);
-}
-/**
- * Convert an `ArrayBuffer` to a binary string.
- *
- * Example:
- *
- * ```js
- * var myString = blobUtil.arrayBufferToBinaryString(arrayBuff)
- * ```
- *
- * @param buffer - array buffer
- * @returns binary string
- */
-function arrayBufferToBinaryString(buffer) {
-  var binary = '';
-  var bytes = new Uint8Array(buffer);
-  var length = bytes.byteLength;
-  var i = -1;
-  while (++i < length) {
-    binary += String.fromCharCode(bytes[i]);
-  }
-  return binary;
-}
-/**
- * Convert a binary string to an `ArrayBuffer`.
- *
- * ```js
- * var myBuffer = blobUtil.binaryStringToArrayBuffer(binaryString)
- * ```
- *
- * @param binary - binary string
- * @returns array buffer
- */
-function binaryStringToArrayBuffer(binary) {
-  var length = binary.length;
-  var buf = new ArrayBuffer(length);
-  var arr = new Uint8Array(buf);
-  var i = -1;
-  while (++i < length) {
-    arr[i] = binary.charCodeAt(i);
-  }
-  return buf;
-}
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -865,6 +708,9 @@ const restoreExistingError = (error, currentStack) => {
 };
 const restoreMethodNotFoundError = (error, currentStack) => {
   const restoredError = new JsonRpcError(error.message);
+  Object.assign(restoredError, {
+    code: error.code
+  });
   const parentStack = getParentStack(error);
   setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
   return restoredError;
@@ -884,9 +730,13 @@ const applyDataProperties = (restoredError, error) => {
     // @ts-ignore
     restoredError.codeFrame = error.data.codeFrame;
   }
-  if (error.data.code) {
+  if (typeof error.data.code === 'string' || typeof error.data.code === 'number') {
     // @ts-ignore
-    restoredError.code = error.data.code;
+    Object.defineProperty(restoredError, 'code', {
+      configurable: true,
+      value: error.data.code,
+      writable: true
+    });
   }
   if (error.data.type) {
     // @ts-ignore
@@ -907,7 +757,14 @@ const applyDirectProperties = (restoredError, error) => {
   }
 };
 const restoreMessageError = (error, _currentStack) => {
-  const restoredError = constructError(error.message, error.type, error.name);
+  const restoredError = constructError(error.message, error.type || error.data?.type, error.name);
+  if (typeof error.code === 'string' || typeof error.code === 'number') {
+    Object.defineProperty(restoredError, 'code', {
+      configurable: true,
+      value: error.code,
+      writable: true
+    });
+  }
   if (error.data) {
     applyDataProperties(restoredError, error);
   } else {
@@ -915,6 +772,23 @@ const restoreMessageError = (error, _currentStack) => {
   }
   return restoredError;
 };
+const getFallbackMessage = error => {
+  if (error && typeof error.message === 'string' && error.message) {
+    return error.message;
+  }
+  if (error && error.data) {
+    return getFallbackMessage(error.data);
+  }
+  const stringified = String(error);
+  if (stringified !== '[object Object]') {
+    return stringified;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return stringified;
+  }
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
@@ -923,13 +797,13 @@ const restoreJsonRpcError = error => {
   if (error && error.code && error.code === MethodNotFound) {
     return restoreMethodNotFoundError(error, currentStack);
   }
+  if (error && error.error) {
+    return restoreJsonRpcError(error.error);
+  }
   if (error && error.message) {
     return restoreMessageError(error);
   }
-  if (typeof error === 'string') {
-    return new Error(`JsonRpc Error: ${error}`);
-  }
-  return new Error(`JsonRpc Error: ${error}`);
+  return new Error(`JsonRpc Error: ${getFallbackMessage(error)}`);
 };
 const unwrapJsonRpcResult = responseMessage => {
   if ('error' in responseMessage) {
@@ -986,9 +860,9 @@ const getErrorProperty = (error, prettyError) => {
   return {
     code: Custom,
     data: {
-      code: prettyError.code,
+      code: prettyError.code ?? error?.code,
       codeFrame: prettyError.codeFrame,
-      name: prettyError.name,
+      name: prettyError.name ?? error?.name,
       stack: getStack(prettyError),
       type: getErrorType(prettyError)
     },
@@ -1023,7 +897,12 @@ const getErrorResponseSimple = (id, error) => {
   return {
     error: {
       code: Custom,
-      data: error,
+      data: error instanceof Error ? {
+        ...error,
+        code: 'code' in error ? error.code : undefined,
+        stack: error.stack,
+        type: error.name
+      } : error,
       // @ts-ignore
       message: error.message
     },
@@ -1547,22 +1426,22 @@ const exists$4 = async uri => {
 };
 
 const FileSystemProcess = {
-   __proto__: null,
-   appendFile: appendFile$2,
-   copy: copy$4,
-   exists: exists$4,
-   getFolderSize: getFolderSize$4,
-   getRealPath: getRealPath$4,
-   invoke: invoke$3,
-   mkdir: mkdir$4,
-   readDirWithFileTypes: readDirWithFileTypes$4,
-   readFile: readFile$4,
-   readJson: readJson$4,
-   remove: remove$4,
-   rename: rename$4,
-   set: set$3,
-   stat: stat$4,
-   writeFile: writeFile$4
+  __proto__: null,
+  appendFile: appendFile$2,
+  copy: copy$4,
+  exists: exists$4,
+  getFolderSize: getFolderSize$4,
+  getRealPath: getRealPath$4,
+  invoke: invoke$3,
+  mkdir: mkdir$4,
+  readDirWithFileTypes: readDirWithFileTypes$4,
+  readFile: readFile$4,
+  readJson: readJson$4,
+  remove: remove$4,
+  rename: rename$4,
+  set: set$3,
+  stat: stat$4,
+  writeFile: writeFile$4
 };
 
 const createLazyRpc = rpcId => {
@@ -1647,9 +1526,9 @@ const {
   invokeAndTransfer,
   set: set$1
 } = create(RendererWorker);
-const sendMessagePortToRendererProcess = async port => {
+const sendMessagePortToRendererProcess = async (port, rpcId = DebugWorker) => {
   const command = 'HandleMessagePort.handleMessagePort';
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, rpcId);
 };
 const sendMessagePortToFileSystemProcess$1 = async (port, rpcId) => {
   const command = 'HandleMessagePortForFileSystemProcess.handleMessagePortForFileSystemProcess';
@@ -1907,23 +1786,23 @@ const getFiles = async () => {
 };
 
 const FileSystemMemory = {
-   __proto__: null,
-   copy: copy$2,
-   createFile: createFile$2,
-   exists: exists$2,
-   getFiles,
-   getFolderSize: getFolderSize$2,
-   getPathSeparator: getPathSeparator$1,
-   getRealPath: getRealPath$2,
-   mkdir: mkdir$2,
-   readDirWithFileTypes: readDirWithFileTypes$2,
-   readFile: readFile$2,
-   readFileAsBlob: readFileAsBlob$2,
-   readJson: readJson$2,
-   remove: remove$2,
-   rename: rename$2,
-   stat: stat$2,
-   writeFile: writeFile$2
+  __proto__: null,
+  copy: copy$2,
+  createFile: createFile$2,
+  exists: exists$2,
+  getFiles,
+  getFolderSize: getFolderSize$2,
+  getPathSeparator: getPathSeparator$1,
+  getRealPath: getRealPath$2,
+  mkdir: mkdir$2,
+  readDirWithFileTypes: readDirWithFileTypes$2,
+  readFile: readFile$2,
+  readFileAsBlob: readFileAsBlob$2,
+  readJson: readJson$2,
+  remove: remove$2,
+  rename: rename$2,
+  stat: stat$2,
+  writeFile: writeFile$2
 };
 
 const memoryRoot = id => `memfs:///applications/${encodeURIComponent(id)}`;
@@ -1949,34 +1828,6 @@ const execute = async (id, method, ...args) => {
 };
 const dispose = async id => remove$2(memoryRoot(id));
 
-const normalizeBlobError = error => {
-  const ProgressEventConstructor = ProgressEvent;
-  if (error && ProgressEventConstructor && error instanceof ProgressEventConstructor && error.target &&
-  // @ts-expect-error - target.error may not be in the type definition
-  error.target.error) {
-    // @ts-expect-error - target.error may not be in the type definition
-    return error.target.error;
-  }
-  return error;
-};
-
-const binaryStringToBlob = async (string, type) => {
-  try {
-    return binaryStringToBlob$1(string, type);
-  } catch (error) {
-    const normalizedError = normalizeBlobError(error);
-    throw new VError(normalizedError, 'Failed to convert binary string to blob');
-  }
-};
-const blobToBinaryString = async blob => {
-  try {
-    return await blobToBinaryString$1(blob);
-  } catch (error) {
-    const normalizedError = normalizeBlobError(error);
-    throw new VError(normalizedError, 'Failed to convert blob to binary string');
-  }
-};
-
 const connect = async port => {
   const {
     commandMap
@@ -2047,21 +1898,21 @@ const getFolderSize$1 = async uri => {
 };
 
 const FileSystemFetch = {
-   __proto__: null,
-   copy: copy$1,
-   createFile: createFile$1,
-   exists: exists$1,
-   getFolderSize: getFolderSize$1,
-   getRealPath: getRealPath$1,
-   mkdir: mkdir$1,
-   readDirWithFileTypes: readDirWithFileTypes$1,
-   readFile: readFile$1,
-   readFileAsBlob: readFileAsBlob$1,
-   readJson: readJson$1,
-   remove: remove$1,
-   rename: rename$1,
-   stat: stat$1,
-   writeFile: writeFile$1
+  __proto__: null,
+  copy: copy$1,
+  createFile: createFile$1,
+  exists: exists$1,
+  getFolderSize: getFolderSize$1,
+  getRealPath: getRealPath$1,
+  mkdir: mkdir$1,
+  readDirWithFileTypes: readDirWithFileTypes$1,
+  readFile: readFile$1,
+  readFileAsBlob: readFileAsBlob$1,
+  readJson: readJson$1,
+  remove: remove$1,
+  rename: rename$1,
+  stat: stat$1,
+  writeFile: writeFile$1
 };
 
 const isFetch = uri => {
@@ -2171,6 +2022,9 @@ const readFileAsBlob = async uri => {
     const blob = await response.blob();
     return blob;
   }
+  if (isProviderUri(uri)) {
+    return invoke$2('FileSystem.getBlob', uri);
+  }
   throw new Error('uri not supported');
 };
 const stat = async dirent => {
@@ -2243,28 +2097,28 @@ const getPathSeparator = async uri => {
 };
 
 const FileSystemDisk = {
-   __proto__: null,
-   appendFile,
-   copy,
-   createFile,
-   exists,
-   getFileHash,
-   getFileHashes,
-   getFileSize,
-   getFolderSize,
-   getPathSeparator,
-   getRealPath,
-   isReadonly,
-   mkdir,
-   readDirWithFileTypes,
-   readFile,
-   readFileAsBlob,
-   readJson,
-   remove,
-   rename,
-   stat,
-   writeBlob,
-   writeFile
+  __proto__: null,
+  appendFile,
+  copy,
+  createFile,
+  exists,
+  getFileHash,
+  getFileHashes,
+  getFileSize,
+  getFolderSize,
+  getPathSeparator,
+  getRealPath,
+  isReadonly,
+  mkdir,
+  readDirWithFileTypes,
+  readFile,
+  readFileAsBlob,
+  readJson,
+  remove,
+  rename,
+  stat,
+  writeBlob,
+  writeFile
 };
 
 const createGlobImplementation = () => {
@@ -2639,8 +2493,14 @@ const uploadDirectory = async (fileSystemHandle, pathSeparator, root, uploadHand
   await uploadHandles(childHandles, pathSeparator, folderPath);
 };
 
-const getBinaryString$1 = file => {
-  return blobToBinaryString(file);
+const getBinaryString$1 = async file => {
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  const chunks = [];
+  const chunkSize = 32_768;
+  for (let i = 0; i < bytes.length; i += chunkSize) {
+    chunks.push(String.fromCodePoint(...bytes.subarray(i, i + chunkSize)));
+  }
+  return chunks.join('');
 };
 
 const getFile = handle => {
@@ -2701,9 +2561,6 @@ const uploadFileSystemHandles = async (root, pathSeparator, fileSystemHandles) =
 const commandMap = {
   'ApplicationFileSystem.dispose': dispose,
   'ApplicationFileSystem.execute': execute,
-  'Blob.base64StringToBlob': base64StringToBlob,
-  'Blob.binaryStringToBlob': binaryStringToBlob,
-  'Blob.blobToBinaryString': blobToBinaryString,
   'FileSystem.appendFile': appendFile,
   'FileSystem.connect': connect,
   'FileSystem.copy': copy,
@@ -2737,8 +2594,8 @@ const commandMap = {
 };
 
 const CommandMap = {
-   __proto__: null,
-   commandMap
+  __proto__: null,
+  commandMap
 };
 
 /* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */

package/package.json

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