@lvce-editor/auth-worker 3.22.2 → 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);
@@ -1102,6 +1111,7 @@ const create = rpcId => {
 };
 
 const {
+  dispose,
   invoke: invoke$3,
   set: set$2
 } = create(6040);
@@ -1135,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);
@@ -1248,22 +1342,22 @@ const getAuthBackendUrl = async backendUrl => {
   return invoke('Layout.getBackendUrl');
 };
 
-const state$3 = {
+const state$4 = {
   platform: Web,
   useNativeAuth: false
 };
 const getAuthPlatform = () => {
-  return state$3.platform;
+  return state$4.platform;
 };
 const setAuthPlatform = value => {
-  state$3.platform = value;
+  state$4.platform = value;
 };
 
 // Native shells can use loopback OAuth without Electron's process or secret storage.
 const setUseNativeAuth = value => {
-  state$3.useNativeAuth = value;
+  state$4.useNativeAuth = value;
 };
-const getUseNativeAuth = () => state$3.useNativeAuth;
+const getUseNativeAuth = () => state$4.useNativeAuth;
 
 let USER_AGENT;
 if (typeof navigator === 'undefined' || !navigator.userAgent?.startsWith?.('Mozilla/5.0 ')) {
@@ -2435,15 +2529,15 @@ const databaseName = 'auth-worker';
 const objectStoreName = 'auth';
 const memoryStorage = new Map();
 const secretKeys = new Set(['accessToken', 'refreshToken', 'accountSessions']);
-const state$2 = {
+const state$3 = {
   databasePromise: undefined
 };
 const getDatabase = async () => {
   if (typeof indexedDB === 'undefined') {
     return undefined;
   }
-  if (!state$2.databasePromise) {
-    state$2.databasePromise = openDB(databaseName, 1, {
+  if (!state$3.databasePromise) {
+    state$3.databasePromise = openDB(databaseName, 1, {
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
       upgrade(database) {
         if (!database.objectStoreNames.contains(objectStoreName)) {
@@ -2452,7 +2546,7 @@ const getDatabase = async () => {
       }
     });
   }
-  return state$2.databasePromise;
+  return state$3.databasePromise;
 };
 const getIndexedDbValue = async key => {
   const database = await getDatabase();
@@ -2640,40 +2734,40 @@ 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 state$1 = {
+const getBackendRefreshUrl = backendUrl => {
+  return getBackendAuthUrl(backendUrl, '/auth/refresh');
+};
+
+const state$2 = {
   nextLoginResponse: undefined,
   nextRefreshResponse: undefined
 };
 const setNextLoginResponse = response => {
-  state$1.nextLoginResponse = response;
+  state$2.nextLoginResponse = response;
 };
 const setNextRefreshResponse = response => {
-  state$1.nextRefreshResponse = response;
+  state$2.nextRefreshResponse = response;
 };
 const clear = () => {
-  state$1.nextLoginResponse = undefined;
-  state$1.nextRefreshResponse = undefined;
+  state$2.nextLoginResponse = undefined;
+  state$2.nextRefreshResponse = undefined;
 };
 const hasPendingMockLoginResponse = () => {
-  return !!state$1.nextLoginResponse;
+  return !!state$2.nextLoginResponse;
 };
 const hasPendingMockRefreshResponse = () => {
-  return !!state$1.nextRefreshResponse;
+  return !!state$2.nextRefreshResponse;
 };
 const consumeNextLoginResponse = async () => {
-  if (!state$1.nextLoginResponse) {
+  if (!state$2.nextLoginResponse) {
     return undefined;
   }
-  const response = state$1.nextLoginResponse;
-  state$1.nextLoginResponse = undefined;
+  const response = state$2.nextLoginResponse;
+  state$2.nextLoginResponse = undefined;
   if (response.delay > 0) {
     await delay(response.delay);
   }
@@ -2683,11 +2777,11 @@ const consumeNextLoginResponse = async () => {
   return response.response;
 };
 const consumeNextRefreshResponse = async () => {
-  if (!state$1.nextRefreshResponse) {
+  if (!state$2.nextRefreshResponse) {
     return undefined;
   }
-  const response = state$1.nextRefreshResponse;
-  state$1.nextRefreshResponse = undefined;
+  const response = state$2.nextRefreshResponse;
+  state$2.nextRefreshResponse = undefined;
   if (response.delay > 0) {
     await new Promise(resolve => setTimeout(resolve, response.delay));
   }
@@ -3302,6 +3396,9 @@ const waitForElectronBackendLogin = async (backendUrl, uid, redirectUri, codeVer
   return getLoggedOutBackendAuthState('Timed out waiting for backend login.');
 };
 
+const state$1 = {
+  nativeLoginCount: 0
+};
 const getMockLoginResult = async (signingInState, persistResult) => {
   if (!hasPendingMockLoginResponse()) {
     return undefined;
@@ -3322,10 +3419,13 @@ const getMockLoginResult = async (signingInState, persistResult) => {
   return persistResult(getLoggedInState(signingInState, response));
 };
 const getInteractiveLoginResult = async (backendUrl, platform, signingInState, persistResult, selectAccount) => {
-  const nativeAuth = getUseNativeAuth();
+  const nativeAuth = getUseNativeAuth() || platform === Electron;
   const transportPlatform = nativeAuth ? Electron : platform;
   const authUseRedirect = getAuthUseRedirect(transportPlatform);
   const uid = nativeAuth ? globalThis.crypto.randomUUID() : 0;
+  if (nativeAuth) {
+    state$1.nativeLoginCount++;
+  }
   try {
     const {
       clientId,
@@ -3358,7 +3458,14 @@ const getInteractiveLoginResult = async (backendUrl, platform, signingInState, p
     });
   } finally {
     if (nativeAuth) {
-      await invoke$3('OAuthServer.dispose', String(uid));
+      try {
+        await invoke$3('OAuthServer.dispose', String(uid));
+      } finally {
+        state$1.nativeLoginCount--;
+        if (state$1.nativeLoginCount === 0) {
+          await dispose();
+        }
+      }
     }
   }
 };
@@ -3677,36 +3784,24 @@ const approveCloudflareMachine = (id, code, zoneId) => {
   });
 };
 
-const sendMessagePortToAuthProcess = async port => {
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess', port, 'HandleMessagePortForAuthProcess.handleMessagePortForAuthProcess');
-};
-const initializeAuthProcess = async () => {
-  const rpc = await create$2({
-    commandMap: {},
-    send: sendMessagePortToAuthProcess
-  });
-  set$2(rpc);
+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.2",
+  "version": "3.23.0",
   "description": "Auth Worker",
   "repository": {
     "type": "git",