@expo/metro-runtime 3.0.1 → 3.0.2

package/src/location/Location.native.ts

@@ -0,0 +1,201 @@
+// Copyright © 2023 650 Industries.
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+
+import URL from 'url-parse';
+
+class DOMException extends Error {
+  constructor(message: string, name: string) {
+    super(message);
+    this.name = name;
+  }
+}
+
+// The differences between the definitions of `Location` and `WorkerLocation`
+// are because of the `LegacyUnforgeable` attribute only specified upon
+// `Location`'s properties. See:
+// - https://html.spec.whatwg.org/multipage/history.html#the-location-interface
+// - https://heycam.github.io/webidl/#LegacyUnforgeable
+class Location {
+  constructor(href: string | null = null) {
+    const url = new URL(
+      // @ts-expect-error
+      href
+    );
+    // @ts-expect-error
+    url.username = '';
+    // @ts-expect-error
+    url.password = '';
+    Object.defineProperties(this, {
+      hash: {
+        get() {
+          return url.hash;
+        },
+        set() {
+          throw new DOMException(`Cannot set "location.hash".`, 'NotSupportedError');
+        },
+        enumerable: true,
+      },
+      host: {
+        get() {
+          return url.host;
+        },
+        set() {
+          throw new DOMException(`Cannot set "location.host".`, 'NotSupportedError');
+        },
+        enumerable: true,
+      },
+      hostname: {
+        get() {
+          return url.hostname;
+        },
+        set() {
+          throw new DOMException(`Cannot set "location.hostname".`, 'NotSupportedError');
+        },
+        enumerable: true,
+      },
+      href: {
+        get() {
+          return url.href;
+        },
+        set() {
+          throw new DOMException(`Cannot set "location.href".`, 'NotSupportedError');
+        },
+        enumerable: true,
+      },
+      origin: {
+        get() {
+          return url.origin;
+        },
+        enumerable: true,
+      },
+      pathname: {
+        get() {
+          return url.pathname;
+        },
+        set() {
+          throw new DOMException(`Cannot set "location.pathname".`, 'NotSupportedError');
+        },
+        enumerable: true,
+      },
+      port: {
+        get() {
+          return url.port;
+        },
+        set() {
+          throw new DOMException(`Cannot set "location.port".`, 'NotSupportedError');
+        },
+        enumerable: true,
+      },
+      protocol: {
+        get() {
+          return url.protocol;
+        },
+        set() {
+          throw new DOMException(`Cannot set "location.protocol".`, 'NotSupportedError');
+        },
+        enumerable: true,
+      },
+      search: {
+        get() {
+          // @ts-expect-error
+          return url.search;
+        },
+        set() {
+          throw new DOMException(`Cannot set "location.search".`, 'NotSupportedError');
+        },
+        enumerable: true,
+      },
+      ancestorOrigins: {
+        get() {
+          return {
+            length: 0,
+            item: () => null,
+            contains: () => false,
+          };
+        },
+        enumerable: true,
+      },
+      assign: {
+        value: function assign() {
+          throw new DOMException(`Cannot call "location.assign()".`, 'NotSupportedError');
+        },
+        enumerable: true,
+      },
+      reload: {
+        value: function reload() {
+          if (process.env.NODE_ENV !== 'production') {
+            // NOTE: This does change how native fast refresh works. The upstream metro-runtime will check
+            // if `location.reload` exists before falling back on an implementation that is nearly identical to
+            // this. The main difference is that on iOS there is a "reason" message sent, but at the time of writing
+            // this, that message is unused (ref: `RCTTriggerReloadCommandNotification`).
+            const DevSettings = (require('react-native') as typeof import('react-native'))
+              .DevSettings;
+            return DevSettings.reload();
+          } else {
+            throw new DOMException(`Cannot call "location.reload()".`, 'NotSupportedError');
+          }
+        },
+        enumerable: true,
+      },
+      replace: {
+        value: function replace() {
+          throw new DOMException(`Cannot call "location.replace()".`, 'NotSupportedError');
+        },
+        enumerable: true,
+      },
+      toString: {
+        value: function toString() {
+          return url.href;
+        },
+        enumerable: true,
+      },
+      [Symbol.for('Expo.privateCustomInspect')]: {
+        value(inspect: any) {
+          const object = {
+            hash: this.hash,
+            host: this.host,
+            hostname: this.hostname,
+            href: this.href,
+            origin: this.origin,
+            pathname: this.pathname,
+            port: this.port,
+            protocol: this.protocol,
+            search: this.search,
+          };
+          return `${this.constructor.name} ${inspect(object)}`;
+        },
+      },
+    });
+  }
+}
+
+Object.defineProperties(Location.prototype, {
+  [Symbol.toString()]: {
+    value: 'Location',
+    configurable: true,
+  },
+});
+
+let location: Location | undefined = undefined;
+
+export function setLocationHref(href: string) {
+  location = new Location(href);
+}
+
+export function install() {
+  Object.defineProperty(global, 'Location', {
+    value: Location,
+    configurable: true,
+    writable: true,
+  });
+
+  Object.defineProperty(window, 'location', {
+    get() {
+      return location;
+    },
+    set() {
+      throw new DOMException(`Cannot set "location".`, 'NotSupportedError');
+    },
+    enumerable: true,
+  });
+}

package/src/location/Location.ts

@@ -0,0 +1,3 @@
+export function install() {}
+
+export function setLocationHref(href: string) {}

package/src/location/install.native.ts

@@ -0,0 +1,90 @@
+// This MUST be first to ensure that `fetch` is defined in the React Native environment.
+import 'react-native/Libraries/Core/InitializeCore';
+
+import Constants from 'expo-constants';
+import URL from 'url-parse';
+
+import { install, setLocationHref } from './Location';
+import getDevServer from '../getDevServer';
+
+let hasWarned = false;
+
+const manifest = Constants.expoConfig as Record<string, any> | null;
+
+// Add a development warning for fetch requests with relative paths
+// to ensure developers are aware of the need to configure a production
+// base URL in the Expo config (app.json) under `expo.extra.router.origin`.
+function warnProductionOriginNotConfigured(requestUrl: string) {
+  if (hasWarned) {
+    return;
+  }
+  hasWarned = true;
+  if (!manifest?.extra?.router?.origin) {
+    console.warn(
+      `The relative fetch request "${requestUrl}" will not work in production until the Expo Router Config Plugin (app.json) is configured with the \`origin\` prop set to the base URL of your web server, e.g. \`{ plugins: [["expo-router", { origin: "..." }]] }\`. [Learn more](https://expo.github.io/router/docs/lab/runtime-location)`
+    );
+  }
+}
+
+// TODO: This would be better if native and tied as close to the JS engine as possible, i.e. it should
+// reflect the exact location of the JS file that was executed.
+function getBaseUrl() {
+  if (process.env.NODE_ENV !== 'production') {
+    // e.g. http://localhost:19006
+    return getDevServer().url?.replace(/\/$/, '');
+  }
+
+  // TODO: Make it official by moving out of `extra`
+  const productionBaseUrl = manifest?.extra?.router?.origin;
+
+  if (!productionBaseUrl) {
+    return null;
+  }
+
+  // Ensure no trailing slash
+  return productionBaseUrl?.replace(/\/$/, '');
+}
+
+function wrapFetchWithWindowLocation(fetch: Function & { __EXPO_BASE_URL_POLYFILLED?: boolean }) {
+  if (fetch.__EXPO_BASE_URL_POLYFILLED) {
+    return fetch;
+  }
+
+  const _fetch = (...props: any[]) => {
+    if (props[0] && typeof props[0] === 'string' && props[0].startsWith('/')) {
+      if (process.env.NODE_ENV !== 'production') {
+        warnProductionOriginNotConfigured(props[0]);
+      }
+
+      props[0] = new URL(props[0], window.location?.origin).toString();
+    } else if (props[0] && typeof props[0] === 'object') {
+      if (props[0].url && typeof props[0].url === 'string' && props[0].url.startsWith('/')) {
+        if (process.env.NODE_ENV !== 'production') {
+          warnProductionOriginNotConfigured(props[0]);
+        }
+
+        props[0].url = new URL(props[0].url, window.location?.origin).toString();
+      }
+    }
+    return fetch(...props);
+  };
+
+  _fetch.__EXPO_BASE_URL_POLYFILLED = true;
+
+  return _fetch;
+}
+
+if (manifest?.extra?.router?.origin !== false) {
+  // Polyfill window.location in native runtimes.
+  if (typeof window !== 'undefined' && !window.location) {
+    const url = getBaseUrl();
+    if (url) {
+      setLocationHref(url);
+      install();
+    }
+  }
+  // Polyfill native fetch to support relative URLs
+  Object.defineProperty(global, 'fetch', {
+    value: wrapFetchWithWindowLocation(fetch),
+  });
+}

package/src/messageSocket.ts

@@ -0,0 +1,25 @@
+/* eslint-env browser */
+
+// Setup websocket messages for reloading the page from the command line.
+// This is normally setup on the native client.
+
+const protocol = window.location.protocol === 'https:' ? 'wss' : 'ws';
+const messageSocket = new WebSocket(`${protocol}://${window.location.host}/message`);
+messageSocket.onmessage = (message) => {
+  const data = JSON.parse(String(message.data));
+  switch (data.method) {
+    case 'sendDevCommand':
+      switch (data.params.name) {
+        case 'reload':
+          window.location.reload();
+          break;
+      }
+      break;
+    case 'reload':
+      window.location.reload();
+      break;
+    case 'devMenu':
+      // no-op
+      break;
+  }
+};

package/src/setupFastRefresh.ts

@@ -0,0 +1,30 @@
+// This needs to run before the renderer initializes.
+
+const ReactRefreshRuntime = require('react-refresh/runtime');
+ReactRefreshRuntime.injectIntoGlobalHook(global);
+
+const Refresh = {
+  performFullRefresh() {
+    location.reload();
+  },
+
+  createSignatureFunctionForTransform: ReactRefreshRuntime.createSignatureFunctionForTransform,
+
+  isLikelyComponentType: ReactRefreshRuntime.isLikelyComponentType,
+
+  getFamilyByType: ReactRefreshRuntime.getFamilyByType,
+
+  register: ReactRefreshRuntime.register,
+
+  performReactRefresh() {
+    if (ReactRefreshRuntime.hasUnrecoverableErrors()) {
+      location.reload();
+      return;
+    }
+    ReactRefreshRuntime.performReactRefresh();
+  },
+};
+
+// The metro require polyfill can not have dependencies (applies for all polyfills).
+// Expose `Refresh` by assigning it to global to make it available in the polyfill.
+global[(global.__METRO_GLOBAL_PREFIX__ || '') + '__ReactRefresh'] = Refresh;

package/src/setupHMR.ts

@@ -0,0 +1,28 @@
+import HMRClient from './HMRClient';
+
+// Sets up developer tools for React Native web.
+// We assume full control over the console and send JavaScript logs to Metro.
+// [
+//   'trace',
+//   'info',
+//   'warn',
+//   'error',
+//   'log',
+//   'group',
+//   'groupCollapsed',
+//   'groupEnd',
+//   'debug',
+// ].forEach(level => {
+//   const originalFunction = console[level];
+//   console[level] = function (...args: readonly any[]) {
+//     HMRClient.log(
+//       // @ts-expect-error
+//       level, args);
+//     originalFunction.apply(console, args);
+//   };
+// });
+
+HMRClient.log('log', [`[web] Logs will appear in the browser console`]);
+
+// This is called native on native platforms
+HMRClient.setup({ isEnabled: true });

package/src/symbolicate.ts

@@ -0,0 +1,6 @@
+import { LogBoxLog } from './error-overlay/Data/LogBoxLog';
+import parseErrorStack from './error-overlay/modules/parseErrorStack';
+
+export { LogBoxLog, parseErrorStack };
+
+export * from './error-overlay/formatProjectFilePath';