@lvce-editor/file-system-worker 1.0.0 → 1.1.0

package/dist/fileSystemWorkerMain.js

@@ -368,6 +368,9 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const Error$3 = 1;
+const Open = 2;
+const Close = 3;
 const addListener = (emitter, type, callback) => {
   if ('addEventListener' in emitter) {
     emitter.addEventListener(type, callback);
@@ -462,9 +465,69 @@ const IpcParentWithMessagePort$1 = {
   signal: signal$1,
   wrap: wrap$5
 };
+const stringifyCompact = value => {
+  return JSON.stringify(value);
+};
+const parse = content => {
+  if (content === 'undefined') {
+    return null;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (error) {
+    throw new VError(error, 'failed to parse json');
+  }
+};
+const waitForWebSocketToBeOpen = webSocket => {
+  return getFirstEvent(webSocket, {
+    open: Open,
+    close: Close,
+    error: Error$3
+  });
+};
+const create$6 = async ({
+  webSocket
+}) => {
+  const firstWebSocketEvent = await waitForWebSocketToBeOpen(webSocket);
+  if (firstWebSocketEvent.type === Error$3) {
+    throw new IpcError(`WebSocket connection error`);
+  }
+  if (firstWebSocketEvent.type === Close) {
+    throw new IpcError('Websocket connection was immediately closed');
+  }
+  return webSocket;
+};
+class IpcParentWithWebSocket extends Ipc {
+  getData(event) {
+    return parse(event.data);
+  }
+  send(message) {
+    this._rawIpc.send(stringifyCompact(message));
+  }
+  sendAndTransfer(message) {
+    throw new Error('sendAndTransfer not supported');
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onClose(callback) {
+    this._rawIpc.addEventListener('close', callback);
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap = webSocket => {
+  return new IpcParentWithWebSocket(webSocket);
+};
+const IpcParentWithWebSocket$1 = {
+  __proto__: null,
+  create: create$6,
+  wrap
+};
 
 const Two = '2.0';
-const create$4 = (method, params) => {
+const create$4$1 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -478,7 +541,7 @@ const set$2 = (id, fn) => {
 const get$1 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
 let id = 0;
@@ -655,7 +718,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 => {
@@ -799,10 +862,10 @@ const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   return unwrapJsonRpcResult(responseMessage);
 };
 const send = (transport, method, ...params) => {
-  const message = create$4(method, params);
+  const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke = (ipc, method, ...params) => {
+const invoke$2 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
 const invokeAndTransfer$1 = (ipc, method, ...params) => {
@@ -835,7 +898,7 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
+      return invoke$2(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
       return invokeAndTransfer$1(ipc, method, ...params);
@@ -906,6 +969,24 @@ const PlainMessagePortRpcParent = {
   create: create$2
 };
 const create$1 = async ({
+  commandMap,
+  webSocket
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithWebSocket$1.create({
+    webSocket
+  });
+  const ipc = IpcParentWithWebSocket$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+const WebSocketRpcParent = {
+  __proto__: null,
+  create: create$1
+};
+const create$4 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -917,18 +998,7 @@ const create$1 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$1
-};
-
-const getPortTuple = () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  return {
-    port1,
-    port2
-  };
+  create: create$4
 };
 
 const rpcs = Object.create(null);
@@ -963,26 +1033,88 @@ const create = rpcId => {
 const RendererWorker$1 = 1;
 const FileSystemProcess$1 = 210;
 const {
-  invokeAndTransfer: invokeAndTransfer$3} = create(RendererWorker$1);
+  invokeAndTransfer: invokeAndTransfer$3,
+  set: set$3
+} = create(RendererWorker$1);
 const RendererWorker = {
   __proto__: null,
-  invokeAndTransfer: invokeAndTransfer$3};
+  invokeAndTransfer: invokeAndTransfer$3,
+  set: set$3
+};
 const {
-  set: set$1
+  invoke: invoke$1,
+  set: set$1$1
 } = create(FileSystemProcess$1);
 const FileSystemProcess = {
   __proto__: null,
+  invoke: invoke$1,
+  set: set$1$1
+};
+
+const {
+  invoke,
   set: set$1
+} = FileSystemProcess;
+
+const remove = async dirent => {
+  return invoke('FileSystem.remove', dirent);
+};
+const readFile = async uri => {
+  return invoke('FileSystem.readFile', uri);
+};
+const readDirWithFileTypes = async uri => {
+  return invoke('FileSystem.readDirWithFileTypes', uri);
+};
+const getPathSeparator = async root => {
+  // @ts-ignore
+  return invoke('FileSystem.getPathSeparator', root);
+};
+const readJson = async uri => {
+  // @ts-ignore
+  return invoke('FileSystem.readJson', uri);
+};
+const getRealPath = async path => {
+  return invoke('FileSystem.getRealPath', path);
+};
+const stat = async dirent => {
+  return invoke('FileSystem.stat', dirent);
+};
+const createFile = async uri => {
+  return invoke('FileSystem.writeFile', uri, '');
+};
+const writeFile = async (uri, content) => {
+  return invoke('FileSystem.writeFile', uri, content);
+};
+const mkdir = async uri => {
+  return invoke('FileSystem.mkdir', uri);
+};
+const rename = async (oldUri, newUri) => {
+  return invoke('FileSystem.rename', oldUri, newUri);
+};
+const copy = async (oldUri, newUri) => {
+  return invoke('FileSystem.copy', oldUri, newUri);
+};
+
+const getPortTuple = () => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  return {
+    port1,
+    port2
+  };
 };
 
 const {
-  invokeAndTransfer} = RendererWorker;
+  invokeAndTransfer,
+  set
+} = RendererWorker;
 
 const FileSystemWorker = 209;
 
 const sendMessagePortToFileSystemProcess = async port => {
   const command = 'HandleMessagePort.handleMessagePort2';
-  // @ts-ignore
   await invokeAndTransfer('SendMessagePortToFileSystemProcess.sendMessagePortToFileSystemProcess', port, command, FileSystemWorker);
 };
 
@@ -1003,10 +1135,37 @@ const createFileSystemProcessRpcElectron = async () => {
   }
 };
 
+const Https = 'https:';
+const Ws = 'ws:';
+const Wss = 'wss:';
+
+const getWebSocketProtocol = locationProtocol => {
+  return locationProtocol === Https ? Wss : Ws;
+};
+
+const getWebSocketUrl = (type, host, locationProtocol) => {
+  const wsProtocol = getWebSocketProtocol(locationProtocol);
+  return `${wsProtocol}//${host}/websocket/${type}`;
+};
+
+const getHost = () => {
+  return location.host;
+};
+const getProtocol = () => {
+  return location.protocol;
+};
+
 const createFileSystemProcessRpcNode = async () => {
   try {
-    // TODO create websocket rpc
-    return {};
+    const host = getHost();
+    const protocol = getProtocol();
+    const wsUrl = getWebSocketUrl('file-system-process', host, protocol);
+    const webSocket = new WebSocket(wsUrl);
+    const rpc = await WebSocketRpcParent.create({
+      webSocket,
+      commandMap: {}
+    });
+    return rpc;
   } catch (error) {
     throw new VError(error, `Failed to create file system process rpc`);
   }
@@ -1026,23 +1185,32 @@ const createFileSystemProcessRpc = async platform => {
   }
 };
 
-const {
-  set
-} = FileSystemProcess;
-
 const initialize = async platform => {
   const rpc = await createFileSystemProcessRpc(platform);
-  set(rpc);
+  set$1(rpc);
 };
 
 const commandMap = {
+  'FileSystem.copy': copy,
+  'FileSystem.createFile': createFile,
+  'FileSystem.getPathSeparator': getPathSeparator,
+  'FileSystem.getRealPath': getRealPath,
+  'FileSystem.mkdir': mkdir,
+  'FileSystem.readDirWithFileTypes': readDirWithFileTypes,
+  'FileSystem.readFile': readFile,
+  'FileSystem.readJson': readJson,
+  'FileSystem.remove': remove,
+  'FileSystem.rename': rename,
+  'FileSystem.stat': stat,
+  'FileSystem.writeFile': writeFile,
   'Initialize.initialize': initialize
 };
 
 const listen = async () => {
-  await WebWorkerRpcClient.create({
+  const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });
+  set(rpc);
 };
 
 const main = async () => {

package/package.json

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