fix: select arm64 by default (#6439)

* Fixed Issue #6364

* Fix arm64 select by default v2

* Fix arm64 select by default v2

* Update util/__tests__/getUserBitnessByArchitecture.test.mjs

Co-authored-by: Brian Muenzenmeyer <[e-mail]>
Signed-off-by: Rahil Shah <[e-mail]>

* Update util/getUserBitnessByArchitecture.ts

Co-authored-by: Brian Muenzenmeyer <[e-mail]>
Signed-off-by: Rahil Shah <[e-mail]>

* Update getUserBitnessByArchitecture.ts

Signed-off-by: Claudio W <[e-mail]>

* chore: fixed lint

---------

Signed-off-by: Rahil Shah <[e-mail]>
Signed-off-by: Claudio W <[e-mail]>
Co-authored-by: Brian Muenzenmeyer <[e-mail]>
Co-authored-by: Claudio W <[e-mail]>

components/Downloads/Release/BitnessDropdown.tsx

···
 import { useDetectOS } from '@/hooks/react-client';
 import { ReleaseContext } from '@/providers/releaseProvider';
 import { bitnessItems, formatDropdownItems } from '@/util/downloadUtils';
+import { getUserBitnessByArchitecture } from '@/util/getUserBitnessByArchitecture';
 
 const parseNumericBitness = (bitness: string) =>
   /^\d+$/.test(bitness) ? Number(bitness) : bitness;
 
 const BitnessDropdown: FC = () => {
-  const { bitness: userBitness } = useDetectOS();
+  const { bitness: userBitness, architecture: userArchitecture } =
+    useDetectOS();
   const { bitness, os, release, setBitness } = useContext(ReleaseContext);
   const t = useTranslations();
 
   // we also reset the bitness when the OS changes, because different OSs have
   // different bitnesses available
-  useEffect(() => setBitness(userBitness), [setBitness, userBitness]);
+
+  useEffect(() => {
+    setBitness(getUserBitnessByArchitecture(userArchitecture, userBitness));
+    // we shouldn't update the effect on setter state change
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [userArchitecture, userBitness]);
 
   // @TODO: We should have a proper utility that gives
   // disabled OSs, Platforms, based on specific criteria

hooks/react-client/__tests__/useDetectOS.test.mjs

···
       expect(result.current).toStrictEqual({
         os: 'WIN',
         bitness: 64,
+        architecture: '',
       });
     });
   });
···
       expect(result.current).toStrictEqual({
         os: 'WIN',
         bitness: 64,
+        architecture: '',
       });
     });
   });
···
       expect(result.current).toStrictEqual({
         os: 'MAC',
         bitness: 86,
+        architecture: '',
       });
     });
   });

hooks/react-client/useDetectOS.ts

···
 
 import type { UserOS } from '@/types/userOS';
 import { detectOS } from '@/util/detectOS';
+import { getArchitecture } from '@/util/getArchitecture';
 import { getBitness } from '@/util/getBitness';
 
 type UserOSState = {
   os: UserOS;
   bitness: number;
+  architecture: string;
 };
 
 const useDetectOS = () => {
   const [userOSState, setUserOSState] = useState<UserOSState>({
     os: 'OTHER',
     bitness: 86,
+    architecture: 'ARM',
   });
 
   useEffect(() => {
-    getBitness().then(bitness => {
-      const userAgent = navigator?.userAgent;
-
-      setUserOSState({
-        os: detectOS(),
-        bitness:
-          bitness === '64' ||
-          userAgent?.includes('WOW64') ||
-          userAgent?.includes('Win64')
-            ? 64
-            : 86,
-      });
-    });
+    Promise.all([getBitness(), getArchitecture()]).then(
+      ([bitness, architecture]) => {
+        const userAgent: string | undefined =
+          (typeof navigator === 'object' && navigator.userAgent) || '';
+        const defaultBitness: number = 86; // Default bitness if unable to determine
+        setUserOSState({
+          os: detectOS(),
+          bitness:
+            bitness === '64' ||
+            userAgent?.includes('WOW64') ||
+            userAgent?.includes('Win64')
+              ? 64
+              : defaultBitness,
+          architecture: architecture ? architecture : '',
+        });
+      }
+    );
   }, []);
 
   return userOSState;

util/__tests__/getUserBitnessByArchitecture.test.mjs

···
+import { getUserBitnessByArchitecture } from '@/util/getUserBitnessByArchitecture';
+
+describe('getUserBitnessByArchitecture', () => {
+  it('should return "arm64" for arm architecture and 64-bit', () => {
+    const result = getUserBitnessByArchitecture('arm', 64);
+    expect(result).toBe('arm64');
+  });
+
+  it('should return the user bitness for other architectures', () => {
+    const result = getUserBitnessByArchitecture('x86', 32);
+    expect(result).toBe(32);
+  });
+});

util/getArchitecture.ts

···
+/// <reference types="user-agent-data-types" />
+
+export const getArchitecture = async () => {
+  // This is necessary to detect Windows 11 on Edge.
+  // [MDN](https://developer.mozilla.org/en-US/docs/Web/API/NavigatorUAData/getHighEntropyValues)
+  // [MSFT](https://learn.microsoft.com/en-us/microsoft-edge/web-platform/how-to-detect-win11)
+  if (typeof navigator?.userAgentData?.getHighEntropyValues === 'function') {
+    const entropyValues = navigator.userAgentData.getHighEntropyValues([
+      'architecture',
+    ]);
+
+    // Apparently in some cases this is not a Promise, we can Promisify it.
+    return Promise.resolve(entropyValues)
+      .then(({ architecture }) => architecture)
+      .catch(() => undefined);
+  }
+
+  return undefined;
+};

util/getUserBitnessByArchitecture.ts

···
+export const getUserBitnessByArchitecture = (
+  userArchitecture: string,
+  userBitness: number
+) => {
+  if (userArchitecture === 'arm' && userBitness === 64) {
+    return 'arm64';
+  }
+
+  return userBitness;
+};