@lvce-editor/opener-worker 1.5.0 → 1.9.0

package/dist/openerWorkerMain.js

@@ -463,6 +463,27 @@ const IpcParentWithMessagePort$1 = {
   wrap: wrap$5
 };
 
+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);
+};
+const getCommand = key => {
+  return commands[key];
+};
+const execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
 const Two$1 = '2.0';
 const callbacks = Object.create(null);
 const get$2 = id => {
@@ -487,12 +508,12 @@ const getErrorConstructor = (message, type) => {
     switch (type) {
       case DomException:
         return DOMException;
-      case TypeError$1:
-        return TypeError;
-      case SyntaxError$1:
-        return SyntaxError;
       case ReferenceError$1:
         return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
       default:
         return Error;
     }
@@ -648,56 +669,56 @@ const getErrorProperty = (error, prettyError) => {
   if (error && error.code === E_COMMAND_NOT_FOUND) {
     return {
       code: MethodNotFound,
-      message: error.message,
-      data: error.stack
+      data: error.stack,
+      message: error.message
     };
   }
   return {
     code: Custom,
-    message: prettyError.message,
     data: {
-      stack: getStack(prettyError),
-      codeFrame: prettyError.codeFrame,
-      type: getErrorType(prettyError),
       code: prettyError.code,
-      name: prettyError.name
-    }
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
   };
 };
-const create$1 = (id, error) => {
+const create$1$1 = (id, error) => {
   return {
-    jsonrpc: Two$1,
+    error,
     id,
-    error
+    jsonrpc: Two$1
   };
 };
 const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1(id, errorProperty);
+  return create$1$1(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create$8 = (message, result) => {
   return {
-    jsonrpc: Two$1,
     id: message.id,
+    jsonrpc: Two$1,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$8(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two$1,
-    id,
     error: {
       code: Custom,
+      data: error,
       // @ts-ignore
-      message: error.message,
-      data: error
-    }
+      message: error.message
+    },
+    id,
+    jsonrpc: Two$1
   };
 };
 const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
@@ -727,35 +748,35 @@ const normalizeParams = args => {
   if (args.length === 1) {
     const options = args[0];
     return {
+      execute: options.execute,
       ipc: options.ipc,
+      logError: options.logError || defaultLogError,
       message: options.message,
-      execute: options.execute,
-      resolve: options.resolve || defaultResolve,
       preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
-      logError: options.logError || defaultLogError,
-      requiresSocket: options.requiresSocket || defaultRequiresSocket
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
     };
   }
   return {
+    execute: args[2],
     ipc: args[0],
+    logError: args[5],
     message: args[1],
-    execute: args[2],
-    resolve: args[3],
     preparePrettyError: args[4],
-    logError: args[5],
-    requiresSocket: args[6]
+    requiresSocket: args[6],
+    resolve: args[3]
   };
 };
 const handleJsonRpcMessage = async (...args) => {
   const options = normalizeParams(args);
   const {
-    message,
-    ipc,
     execute,
-    resolve,
-    preparePrettyError,
+    ipc,
     logError,
-    requiresSocket
+    message,
+    preparePrettyError,
+    requiresSocket,
+    resolve
   } = options;
   if ('id' in message) {
     if ('method' in message) {
@@ -778,36 +799,17 @@ const handleJsonRpcMessage = async (...args) => {
   throw new JsonRpcError('unexpected message');
 };
 
-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);
-};
-const getCommand = key => {
-  return commands[key];
-};
-const execute = (command, ...args) => {
-  const fn = getCommand(command);
-  if (!fn) {
-    throw new CommandNotFoundError(command);
-  }
-  return fn(...args);
-};
-
 const Two = '2.0';
-const create$t = (method, params) => {
+
+const create$7 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
     params
   };
 };
-const create$s = (id, method, params) => {
+
+const create$6 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -816,15 +818,14 @@ const create$s = (id, method, params) => {
   };
   return message;
 };
+
 let id = 0;
-const create$r = () => {
+const create$5 = () => {
   return ++id;
 };
 
-/* eslint-disable n/no-unsupported-features/es-syntax */
-
 const registerPromise = map => {
-  const id = create$r();
+  const id = create$5();
   const {
     promise,
     resolve
@@ -836,13 +837,12 @@ const registerPromise = map => {
   };
 };
 
-// @ts-ignore
 const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
   const {
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$s(id, method, params);
+  const message = create$6(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -878,12 +878,13 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$t(method, params);
+      const message = create$7(method, params);
       ipc.send(message);
     }
   };
   return rpc;
 };
+
 const requiresSocket = () => {
   return false;
 };
@@ -898,6 +899,7 @@ const handleMessage = event => {
   const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
+
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
     ipc.addEventListener('message', handleMessage);
@@ -906,6 +908,7 @@ const handleIpc = ipc => {
     ipc.on('message', handleMessage);
   }
 };
+
 const listen$1 = async (module, options) => {
   const rawIpc = await module.listen(options);
   if (module.signal) {
@@ -914,7 +917,8 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$5 = async ({
+
+const create$4 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -931,19 +935,7 @@ const create$5 = async ({
   messagePort.start();
   return rpc;
 };
-const create$4 = async ({
-  commandMap,
-  messagePort
-}) => {
-  return create$5({
-    commandMap,
-    messagePort
-  });
-};
-const PlainMessagePortRpcParent = {
-  __proto__: null,
-  create: create$4
-};
+
 const create$3 = async ({
   commandMap,
   isMessagePortOpen,
@@ -954,17 +946,24 @@ const create$3 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$4({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
-const TransferMessagePortRpcParent = {
-  __proto__: null,
-  create: create$3
-};
+
 const create$2 = async ({
+  commandMap,
+  messagePort
+}) => {
+  return create$4({
+    commandMap,
+    messagePort
+  });
+};
+
+const create$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -974,10 +973,7 @@ const create$2 = async ({
   const rpc = createRpc(ipc);
   return rpc;
 };
-const WebWorkerRpcClient = {
-  __proto__: null,
-  create: create$2
-};
+
 const createMockRpc = ({
   commandMap
 }) => {
@@ -998,11 +994,6 @@ const createMockRpc = ({
   return mockRpc;
 };
 
-const Electron = 2;
-
-const RendererWorker = 1;
-const SharedProcess = 1492;
-
 const rpcs = Object.create(null);
 const set$3 = (id, rpc) => {
   rpcs[id] = rpc;
@@ -1051,6 +1042,11 @@ const create = rpcId => {
   };
 };
 
+const Electron = 2;
+
+const RendererWorker = 1;
+const SharedProcess = 1492;
+
 const {
   invoke: invoke$2,
   invokeAndTransfer,
@@ -1058,7 +1054,6 @@ const {
 } = create(RendererWorker);
 const sendMessagePortToSharedProcess = async port => {
   const command = 'HandleElectronMessagePort.handleElectronMessagePort';
-  // @ts-ignore
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, command, 0);
 };
 
@@ -1068,7 +1063,7 @@ const {
 } = create(SharedProcess);
 
 const handleMessagePort = async (port, rpcId) => {
-  const rpc = await PlainMessagePortRpcParent.create({
+  const rpc = await create$2({
     commandMap: {},
     messagePort: port
   });
@@ -1077,23 +1072,31 @@ const handleMessagePort = async (port, rpcId) => {
   }
 };
 
+const initialize = async platform => {
+  if (platform === Electron) {
+    await initializeMainProcess();
+  }
+};
+
 const openNew = async url => {
   await invoke$1('OpenExternal.openExternal', url);
 };
 
-let enabled = false;
-let text = '';
+const state = {
+  enabled: false,
+  text: ''
+};
 const set = value => {
-  enabled = value;
+  state.enabled = value;
 };
 const get = () => {
-  return enabled;
+  return state.enabled;
 };
 const writeUrl = value => {
-  text = value;
+  state.text = value;
 };
 const readUrl = () => {
-  return text;
+  return state.text;
 };
 
 const invoke = async (method, ...params) => {
@@ -1113,10 +1116,10 @@ const OpenExternal = {
   openExternal: openExternal$1
 };
 
-const openUrlWeb = async url => {
+const openUrlWeb = async (url, useRedirect) => {
   try {
     // TODO make platform argument required
-    await invoke$2('Open.openUrl', url);
+    await invoke$2('Open.openUrl', url, useRedirect);
   } catch (error) {
     throw new VError(error, `Failed to open url ${url}`);
   }
@@ -1126,7 +1129,7 @@ const openUrlElectron = async url => {
 };
 
 // TODO add required platform argument
-const openUrl = async (url, platform) => {
+const openUrl = async (url, platform, useRedirect = false) => {
   if (get()) {
     writeUrl(url);
     return;
@@ -1135,7 +1138,7 @@ const openUrl = async (url, platform) => {
     case Electron:
       return openUrlElectron(url);
     default:
-      return openUrlWeb(url);
+      return openUrlWeb(url, useRedirect);
   }
 };
 const {
@@ -1153,21 +1156,22 @@ const getWorkspaceUri = async () => {
   return invoke$2('Workspace.getUri');
 };
 
-let saveDialogMockReturnValue = null;
+const saveDialogMock = {
+  returnValue: null
+};
 const registerSaveDialogMock = value => {
-  saveDialogMockReturnValue = value;
+  saveDialogMock.returnValue = value;
 };
 const clearSaveDialogMock = () => {
-  saveDialogMockReturnValue = null;
+  saveDialogMock.returnValue = null;
 };
 const showSaveDialog = async (title, properties, platform) => {
-  if (saveDialogMockReturnValue !== null) {
-    return saveDialogMockReturnValue;
+  if (saveDialogMock.returnValue !== null) {
+    return saveDialogMock.returnValue;
   }
   if (platform === Electron) {
     return invoke$1('ElectronDialog.showSaveDialog', title, properties);
   }
-  // When running in web, prompt for filename and combine with workspace path
   const fileName = await invoke$2('Prompt.prompt', title);
   if (!fileName) {
     return {
@@ -1185,6 +1189,7 @@ const showSaveDialog = async (title, properties, platform) => {
 const commandMap = {
   'HandleMessagePort.handleMessagePort': handleMessagePort,
   'Open.enableMemoryOpener': enable,
+  'Open.initialize': initialize,
   'Open.openExternal': openExternal,
   'Open.openUrl': openUrl,
   'Open.readOpenedUrl': readOpenedMemory,
@@ -1197,7 +1202,7 @@ const send = async port => {
   await sendMessagePortToSharedProcess(port);
 };
 const initializeMainProcess = async () => {
-  const rpc = await TransferMessagePortRpcParent.create({
+  const rpc = await create$3({
     commandMap: commandMap,
     send
   });
@@ -1205,7 +1210,7 @@ const initializeMainProcess = async () => {
 };
 
 const initializeRendererWorker = async () => {
-  const rpc = await WebWorkerRpcClient.create({
+  const rpc = await create$1({
     commandMap: commandMap
   });
   set$2(rpc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/opener-worker",
-  "version": "1.5.0",
+  "version": "1.9.0",
   "description": "Opener Worker",
   "repository": {
     "type": "git",