@lvce-editor/auth-worker 3.22.3 → 3.23.0

package/dist/authWorkerMain.js

@@ -573,9 +573,12 @@ const applyDataProperties = (restoredError, error) => {
       writable: true
     });
   }
-  if (error.data.type) {
-    // @ts-ignore
-    restoredError.name = error.data.type;
+  const name = error.data.name || error.data.type;
+  if (name) {
+    Object.defineProperty(restoredError, 'name', {
+      configurable: true,
+      value: name
+    });
   }
 };
 const applyDirectProperties = (restoredError, error) => {
@@ -592,7 +595,7 @@ const applyDirectProperties = (restoredError, error) => {
   }
 };
 const restoreMessageError = (error, _currentStack) => {
-  const restoredError = constructError(error.message, error.type || error.data?.type, error.name);
+  const restoredError = constructError(error.message, error.type || error.data?.type, error.name || error.data?.name);
   if (typeof error.code === 'string' || typeof error.code === 'number') {
     Object.defineProperty(restoredError, 'code', {
       configurable: true,
@@ -802,6 +805,12 @@ const handleJsonRpcMessage = async (...args) => {
     requiresSocket,
     resolve
   } = options;
+  if (message === 'ready') {
+    return;
+  }
+  if (!message || typeof message !== 'object') {
+    throw new JsonRpcError('unexpected message');
+  }
   if ('id' in message) {
     if ('method' in message) {
       const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
@@ -1136,6 +1145,90 @@ const {
 const {
   invoke,
   invokeAndTransfer} = create(RendererWorker);
+const createAuthProcessRpc = create => {
+  let pending;
+  const get = () => {
+    if (!pending) {
+      pending = create();
+    }
+    return pending;
+  };
+  return {
+    async dispose() {
+      const previous = pending;
+      pending = undefined;
+      if (previous) {
+        const rpc = await previous;
+        await rpc.dispose();
+      }
+    },
+    async invoke(method, ...params) {
+      const rpc = await get();
+      return rpc.invoke(method, ...params);
+    },
+    async invokeAndTransfer(method, ...params) {
+      const rpc = await get();
+      return rpc.invokeAndTransfer(method, ...params);
+    },
+    send(method, ...params) {
+      void get().then(rpc => rpc.send(method, ...params));
+    }
+  };
+};
+const initializeAuthProcess = async () => {
+  const rpc = createAuthProcessRpc(async () => {
+    const {
+      port1,
+      port2
+    } = new MessageChannel();
+    let resolveClosed;
+    // Promise.withResolvers requires Node 22, while this package supports Node 16.
+    // eslint-disable-next-line unicorn/prefer-promise-with-resolvers
+    const closed = new Promise(resolve => {
+      resolveClosed = resolve;
+    });
+    const handleClose = () => resolveClosed(new Error('Auth process connection closed'));
+    port2.addEventListener('close', handleClose, {
+      once: true
+    });
+    const failOnClose = async () => {
+      throw await closed;
+    };
+    const raceClose = promise => Promise.race([promise, failOnClose()]);
+    try {
+      await raceClose(invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port1, 'HandleMessagePortForAuthProcess.handleMessagePortForAuthProcess'));
+      const messagePortRpc = await create$4({
+        commandMap: {},
+        messagePort: port2
+      });
+      return {
+        async dispose() {
+          handleClose();
+          port2.removeEventListener('close', handleClose);
+          await messagePortRpc.dispose();
+        },
+        invoke: (method, ...params) => raceClose(messagePortRpc.invoke(method, ...params)),
+        invokeAndTransfer: (method, ...params) => raceClose(messagePortRpc.invokeAndTransfer(method, ...params)),
+        send: messagePortRpc.send
+      };
+    } catch (error) {
+      port2.removeEventListener('close', handleClose);
+      port1.close();
+      port2.close();
+      throw error;
+    }
+  });
+  set$2(rpc);
+};
+const initializeMainProcess = async () => {
+  const rpc = await create$2({
+    commandMap: {},
+    send: async port => {
+      await invokeAndTransfer('SendMessagePortToMainProcess.sendMessagePortToMainProcess', port, 'HandleElectronMessagePort.handleElectronMessagePort', 0);
+    }
+  });
+  set$1(rpc);
+};
 const sendMessagePortToOpenerWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
@@ -2641,14 +2734,14 @@ const getAccountProfile = async (backendUrl, accessToken, fetchFn = fetch) => {
   };
 };
 
-const getBackendRefreshUrl = backendUrl => {
-  return getBackendAuthUrl(backendUrl, '/auth/refresh');
-};
-
 const delay = async ms => {
   await new Promise(resolve => setTimeout(resolve, ms));
 };
 
+const getBackendRefreshUrl = backendUrl => {
+  return getBackendAuthUrl(backendUrl, '/auth/refresh');
+};
+
 const state$2 = {
   nextLoginResponse: undefined,
   nextRefreshResponse: undefined
@@ -3691,97 +3784,24 @@ const approveCloudflareMachine = (id, code, zoneId) => {
   });
 };
 
-const connect = async () => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  const closed = Promise.withResolvers();
-  const handleClose = () => closed.resolve(new Error('Auth process connection closed'));
-  port2.addEventListener('close', handleClose, {
-    once: true
-  });
-  const failOnClose = async () => {
-    throw await closed.promise;
-  };
-  const raceClose = promise => Promise.race([promise, failOnClose()]);
-  try {
-    await raceClose(invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port1, 'HandleMessagePortForAuthProcess.handleMessagePortForAuthProcess'));
-    const rpc = await create$4({
-      commandMap: {},
-      messagePort: port2
-    });
-    return {
-      async dispose() {
-        handleClose();
-        port2.removeEventListener('close', handleClose);
-        await rpc.dispose();
-      },
-      invoke: (method, ...params) => raceClose(rpc.invoke(method, ...params)),
-      invokeAndTransfer: (method, ...params) => raceClose(rpc.invokeAndTransfer(method, ...params)),
-      send: rpc.send
-    };
-  } catch (error) {
-    port2.removeEventListener('close', handleClose);
-    port1.close();
-    port2.close();
-    throw error;
-  }
-};
-const createAuthProcessRpc = (create = connect) => {
-  let pending;
-  const get = () => {
-    if (!pending) {
-      pending = create();
-    }
-    return pending;
-  };
-  return {
-    async dispose() {
-      const previous = pending;
-      // Detach before awaiting: a new login may connect while the old port closes.
-      pending = undefined;
-      if (previous) {
-        const rpc = await previous;
-        await rpc.dispose();
-      }
-    },
-    async invoke(method, ...params) {
-      const rpc = await get();
-      return rpc.invoke(method, ...params);
-    },
-    async invokeAndTransfer(method, ...params) {
-      const rpc = await get();
-      return rpc.invokeAndTransfer(method, ...params);
-    },
-    send(method, ...params) {
-      void get().then(rpc => rpc.send(method, ...params));
-    }
-  };
-};
-const initializeAuthProcess = async () => {
-  set$2(createAuthProcessRpc());
+const processInitializers = {
+  initializeAuthProcess: () => initializeAuthProcess(),
+  initializeMainProcess: () => initializeMainProcess()
 };
 
-const sendMessagePortToMainProcess = async port => {
-  await invokeAndTransfer('SendMessagePortToMainProcess.sendMessagePortToMainProcess', port, 'HandleElectronMessagePort.handleElectronMessagePort', 0);
-};
-const initializeMainProcess = async () => {
-  const rpc = await create$2({
-    commandMap: {},
-    send: sendMessagePortToMainProcess
-  });
-  set$1(rpc);
+const getProcessInitializers = (options, initializers = processInitializers) => {
+  if (options.platform === Electron) {
+    return [initializers.initializeAuthProcess, initializers.initializeMainProcess];
+  }
+  if (options.useNativeAuth) {
+    return [initializers.initializeAuthProcess];
+  }
+  return [];
 };
-
 const configure = async options => {
   setAuthPlatform(options.platform);
   setUseNativeAuth(options.useNativeAuth === true);
-  if (options.platform === Electron) {
-    await Promise.all([initializeAuthProcess(), initializeMainProcess()]);
-  } else if (options.useNativeAuth) {
-    await initializeAuthProcess();
-  }
+  await Promise.all(getProcessInitializers(options).map(initialize => initialize()));
 };
 
 const handleMessagePort = async (port, rpcId) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/auth-worker",
-  "version": "3.22.3",
+  "version": "3.23.0",
   "description": "Auth Worker",
   "repository": {
     "type": "git",