chore(internal): improve node 18 shims

Author: stainless-app[bot]

Diff for: package.json

@@ -53,6 +53,10 @@
   "resolutions": {
     "synckit": "0.8.8"
   },
+  "browser": {
+    "./internal/shims/getBuiltinModule.mjs": "./internal/shims/nullGetBuiltinModule.mjs",
+    "./internal/shims/getBuiltinModule.js": "./internal/shims/nullGetBuiltinModule.js"
+  },
   "imports": {
     "@gitpod/sdk": ".",
     "@gitpod/sdk/*": "./src/*"

Diff for: scripts/build

@@ -35,8 +35,6 @@ node scripts/utils/fix-index-exports.cjs
 cp tsconfig.dist-src.json dist/src/tsconfig.json
 cp src/internal/shim-types.d.ts dist/internal/shim-types.d.ts
 cp src/internal/shim-types.d.ts dist/internal/shim-types.d.mts
-mkdir -p dist/internal/shims
-cp src/internal/shims/*.{mjs,js,d.ts,d.mts} dist/internal/shims
 
 node scripts/utils/postprocess-files.cjs
 

Diff for: src/internal/shims/crypto.node.d.mts

@@ -0,0 +1,18 @@
+import { getBuiltinModule } from './getBuiltinModule';
+
+type Crypto = {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/getRandomValues) */
+  getRandomValues<T extends ArrayBufferView | null>(array: T): T;
+  /**
+   * Available only in secure contexts.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/randomUUID)
+   */
+  randomUUID?: () => string;
+};
+export let getCrypto: () => Crypto | undefined = function lazyGetCrypto() {
+  if (getCrypto !== lazyGetCrypto) return getCrypto();
+  const crypto: Crypto = (globalThis as any).crypto || (getBuiltinModule?.('node:crypto') as any)?.webcrypto;
+  getCrypto = () => crypto;
+  return crypto;
+};

Diff for: src/internal/shims/crypto.node.d.ts

@@ -0,0 +1,32 @@
+import { getBuiltinModule } from './getBuiltinModule';
+
+export let getFile = function lazyGetFile(): FileConstructor {
+  if (getFile !== lazyGetFile) return getFile();
+  // We can drop getBuiltinModule once we no longer support Node < 20.0.0
+  const File = (globalThis as any).File ?? (getBuiltinModule?.('node:buffer') as any)?.File;
+  if (!File) throw new Error('`File` is not defined as a global, which is required for file uploads.');
+  getFile = () => File;
+  return File;
+};
+
+type FileConstructor =
+  typeof globalThis extends { File: infer fileConstructor } ? fileConstructor : typeof FallbackFile;
+export type File = InstanceType<FileConstructor>;
+
+// The infer is to make TS show it as a nice union type,
+// instead of literally `ConstructorParameters<typeof Blob>[0]`
+type FallbackBlobSource = ConstructorParameters<typeof Blob>[0] extends infer T ? T : never;
+/**
+ * A [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) provides information about files.
+ */
+declare class FallbackFile extends Blob {
+  constructor(sources: FallbackBlobSource, fileName: string, options?: any);
+  /**
+   * The name of the `File`.
+   */
+  readonly name: string;
+  /**
+   * The last modified date of the `File`.
+   */
+  readonly lastModified: number;
+}

Diff for: src/internal/shims/crypto.node.js

@@ -0,0 +1,64 @@
+/**
+ * Load a Node built-in module. ID may or may not be prefixed by `node:` and
+ * will be normalized. If we used static imports then our bundle size would be bloated by
+ * injected polyfills, and if we used dynamic require then in addition to bundlers logging warnings,
+ * our code would not work when bundled to ESM and run in Node 18.
+ * @param {string} id ID of the built-in to be loaded.
+ * @returns {object|undefined} exports of the built-in. Undefined if the built-in
+ * does not exist.
+ */
+export let getBuiltinModule: null | ((id: string) => object | undefined) = function getBuiltinModuleLazy(
+  id: string,
+): object | undefined {
+  try {
+    if (getBuiltinModule !== getBuiltinModuleLazy) return getBuiltinModule!(id);
+    if ((process as any).getBuiltinModule) {
+      getBuiltinModule = (process as any).getBuiltinModule;
+    } else {
+      /* Fallback implementation for Node 18 */
+      function createFallbackGetBuiltinModule(BuiltinModule: any) {
+        return function getBuiltinModule(id: string): object | undefined {
+          id = BuiltinModule.normalizeRequirableId(String(id));
+          if (!BuiltinModule.canBeRequiredByUsers(id)) {
+            return;
+          }
+          const mod = BuiltinModule.map.get(id);
+          mod.compileForPublicLoader();
+          return mod.exports;
+        };
+      }
+      const magicKey = Math.random() + '';
+      let module: { BuiltinModule: any } | undefined;
+      try {
+        const kClone = Object.getOwnPropertySymbols(Blob.prototype).find(
+          (e) => e.description?.includes('clone'),
+        )!;
+        Object.defineProperty(Object.prototype, magicKey, {
+          get() {
+            module = this;
+            throw null;
+          },
+          configurable: true,
+        });
+        structuredClone(
+          new (class extends Blob {
+            [kClone]() {
+              return {
+                deserializeInfo: 'internal/bootstrap/realm:' + magicKey,
+              };
+            }
+          })([]),
+        );
+      } catch {}
+      delete (Object.prototype as any)[magicKey];
+      if (module) {
+        getBuiltinModule = createFallbackGetBuiltinModule(module.BuiltinModule);
+      } else {
+        getBuiltinModule = () => undefined;
+      }
+    }
+    return getBuiltinModule!(id);
+  } catch {
+    return undefined;
+  }
+};

Diff for: src/internal/shims/crypto.node.mjs

@@ -0,0 +1 @@
+export const getBuiltinModule = null;

Diff for: src/internal/shims/crypto.ts

@@ -1,4 +1,4 @@
-import { File } from './shims/file.node.js';
+import { type File, getFile } from './shims/file';
 import { BlobPart, getName, makeFile, isAsyncIterable } from './uploads';
 import type { FilePropertyBag } from './builtin-types';
 
@@ -90,7 +90,7 @@ export async function toFile(
 
   // If we've been given a `File` we don't need to do anything
   if (isFileLike(value)) {
-    if (File && value instanceof File) {
+    if (value instanceof getFile()) {
       return value;
     }
     return makeFile([await value.arrayBuffer()], value.name);

Diff for: src/internal/shims/file.node.d.mts

@@ -1,7 +1,7 @@
 import { type RequestOptions } from './request-options';
 import type { FilePropertyBag, Fetch } from './builtin-types';
 import type { Gitpod } from '../client';
-import { File } from './shims/file.node.js';
+import { type File, getFile } from './shims/file';
 import { ReadableStreamFrom } from './shims';
 
 export type BlobPart = string | ArrayBuffer | ArrayBufferView | Blob | DataView;
@@ -32,10 +32,7 @@ export function makeFile(
   fileName: string | undefined,
   options?: FilePropertyBag,
 ): File {
-  if (typeof File === 'undefined') {
-    throw new Error('`File` is not defined as a global which is required for file uploads');
-  }
-
+  const File = getFile();
   return new File(fileBits as any, fileName ?? 'unknown_file', options);
 }
 
@@ -129,7 +126,7 @@ export const createForm = async <T = Record<string, unknown>>(
 // We check for Blob not File because Bun.File doesn't inherit from File,
 // but they both inherit from Blob and have a `name` property at runtime.
 const isNamedBlob = (value: object) =>
-  (File && value instanceof File) || (value instanceof Blob && 'name' in value);
+  value instanceof getFile() || (value instanceof Blob && 'name' in value);
 
 const isUploadable = (value: unknown) =>
   typeof value === 'object' &&

Diff for: src/internal/shims/file.node.d.ts

@@ -1,13 +1,19 @@
 // File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
-import { crypto } from '../shims/crypto.node.js';
+import { getCrypto } from '../shims/crypto';
 
 /**
  * https://stackoverflow.com/a/2117523
  */
-export function uuid4() {
-  if (crypto.randomUUID) return crypto.randomUUID();
+export let uuid4 = function () {
+  const crypto = getCrypto();
+  if (crypto?.randomUUID) {
+    uuid4 = crypto.randomUUID.bind(crypto);
+    return crypto.randomUUID();
+  }
+  const u8 = new Uint8Array(1);
+  const randomByte = crypto ? () => crypto.getRandomValues(u8)[0]! : () => (Math.random() * 0xff) & 0xff;
   return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) =>
-    (+c ^ (crypto.getRandomValues(new Uint8Array(1))[0]! & (15 >> (+c / 4)))).toString(16),
+    (+c ^ (randomByte() & (15 >> (+c / 4)))).toString(16),
   );
-}
+};

Diff for: src/internal/shims/file.node.js

@@ -101,7 +101,7 @@ describe('missing File error message', () => {
     await expect(
       uploads.toFile(mockResponse({ url: 'https://example.com/my/audio.mp3' })),
     ).rejects.toMatchInlineSnapshot(
-      `[Error: \`File\` is not defined as a global which is required for file uploads]`,
+      `[Error: \`File\` is not defined as a global, which is required for file uploads.]`,
     );
   });
 });