@alienplatform/platform-api 1.0.68 → 1.3.4

package/src/lib/env.ts

@@ -2,20 +2,20 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-import * as z from "zod/v4"
-import { dlv } from "./dlv.js"
+import * as z from "zod/v4";
+import { dlv } from "./dlv.js";
 
 export interface Env {
-  ALIEN_API_KEY?: string | undefined
+  ALIEN_API_KEY?: string | undefined;
 
-  ALIEN_DEBUG?: boolean | undefined
+  ALIEN_DEBUG?: boolean | undefined;
 }
 
 export const envSchema: z.ZodType<Env, unknown> = z.object({
   ALIEN_API_KEY: z.string().optional(),
 
   ALIEN_DEBUG: z.coerce.boolean().optional(),
-})
+});
 
 /**
  * Checks for the existence of the Deno global object to determine the environment.
@@ -23,35 +23,35 @@ export const envSchema: z.ZodType<Env, unknown> = z.object({
  */
 function isDeno() {
   if ("Deno" in globalThis) {
-    return true
+    return true;
   }
 
-  return false
+  return false;
 }
 
-let envMemo: Env | undefined = undefined
+let envMemo: Env | undefined = undefined;
 /**
  * Reads and validates environment variables.
  */
 export function env(): Env {
   if (envMemo) {
-    return envMemo
+    return envMemo;
   }
 
-  let envObject: Record<string, unknown> = {}
+  let envObject: Record<string, unknown> = {};
   if (isDeno()) {
-    envObject = (globalThis as any).Deno?.env?.toObject?.() ?? {}
+    envObject = (globalThis as any).Deno?.env?.toObject?.() ?? {};
   } else {
-    envObject = dlv(globalThis, "process.env") ?? {}
+    envObject = dlv(globalThis, "process.env") ?? {};
   }
 
-  envMemo = envSchema.parse(envObject)
-  return envMemo
+  envMemo = envSchema.parse(envObject);
+  return envMemo;
 }
 
 /**
  * Clears the cached env object. Useful for testing with a fresh environment.
  */
 export function resetEnv() {
-  envMemo = undefined
+  envMemo = undefined;
 }

package/src/lib/files.ts

@@ -11,32 +11,32 @@
 export async function readableStreamToArrayBuffer(
   readable: ReadableStream<Uint8Array>,
 ): Promise<ArrayBuffer> {
-  const reader = readable.getReader()
-  const chunks: Uint8Array[] = []
+  const reader = readable.getReader();
+  const chunks: Uint8Array[] = [];
 
-  let totalLength = 0
-  let done = false
+  let totalLength = 0;
+  let done = false;
 
   while (!done) {
-    const { value, done: doneReading } = await reader.read()
+    const { value, done: doneReading } = await reader.read();
 
     if (doneReading) {
-      done = true
+      done = true;
     } else {
-      chunks.push(value)
-      totalLength += value.length
+      chunks.push(value);
+      totalLength += value.length;
     }
   }
 
-  const concatenatedChunks = new Uint8Array(totalLength)
-  let offset = 0
+  const concatenatedChunks = new Uint8Array(totalLength);
+  let offset = 0;
 
   for (const chunk of chunks) {
-    concatenatedChunks.set(chunk, offset)
-    offset += chunk.length
+    concatenatedChunks.set(chunk, offset);
+    offset += chunk.length;
   }
 
-  return concatenatedChunks.buffer as ArrayBuffer
+  return concatenatedChunks.buffer as ArrayBuffer;
 }
 
 /**
@@ -44,10 +44,10 @@ export async function readableStreamToArrayBuffer(
  * Returns null if the extension is not recognized.
  */
 export function getContentTypeFromFileName(fileName: string): string | null {
-  if (!fileName) return null
+  if (!fileName) return null;
 
-  const ext = fileName.toLowerCase().split(".").pop()
-  if (!ext) return null
+  const ext = fileName.toLowerCase().split(".").pop();
+  if (!ext) return null;
 
   const mimeTypes: Record<string, string> = {
     json: "application/json",
@@ -76,7 +76,7 @@ export function getContentTypeFromFileName(fileName: string): string | null {
     woff2: "font/woff2",
     ttf: "font/ttf",
     otf: "font/otf",
-  }
+  };
 
-  return mimeTypes[ext] || null
+  return mimeTypes[ext] || null;
 }

package/src/lib/http.ts

@@ -2,9 +2,12 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 
-export type Fetcher = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>
+export type Fetcher = (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+) => Promise<Response>;
 
-export type Awaitable<T> = T | Promise<T>
+export type Awaitable<T> = T | Promise<T>;
 
 const DEFAULT_FETCHER: Fetcher = (input, init) => {
   // If input is a Request and init is undefined, Bun will discard the method,
@@ -12,64 +15,64 @@ const DEFAULT_FETCHER: Fetcher = (input, init) => {
   // Node.js and browers would ignore an undefined init value. This check is
   // therefore needed for interop with Bun.
   if (init == null) {
-    return fetch(input)
+    return fetch(input);
   } else {
-    return fetch(input, init)
+    return fetch(input, init);
   }
-}
+};
 
 export type RequestInput = {
   /**
    * The URL the request will use.
    */
-  url: URL
+  url: URL;
   /**
    * Options used to create a [`Request`](https://developer.mozilla.org/en-US/docs/Web/API/Request/Request).
    */
-  options?: RequestInit | undefined
-}
+  options?: RequestInit | undefined;
+};
 
 export interface HTTPClientOptions {
-  fetcher?: Fetcher
+  fetcher?: Fetcher;
 }
 
-export type BeforeRequestHook = (req: Request) => Awaitable<Request | void>
-export type RequestErrorHook = (err: unknown, req: Request) => Awaitable<void>
-export type ResponseHook = (res: Response, req: Request) => Awaitable<void>
+export type BeforeRequestHook = (req: Request) => Awaitable<Request | void>;
+export type RequestErrorHook = (err: unknown, req: Request) => Awaitable<void>;
+export type ResponseHook = (res: Response, req: Request) => Awaitable<void>;
 
 export class HTTPClient {
-  private fetcher: Fetcher
-  private requestHooks: BeforeRequestHook[] = []
-  private requestErrorHooks: RequestErrorHook[] = []
-  private responseHooks: ResponseHook[] = []
+  private fetcher: Fetcher;
+  private requestHooks: BeforeRequestHook[] = [];
+  private requestErrorHooks: RequestErrorHook[] = [];
+  private responseHooks: ResponseHook[] = [];
 
   constructor(private options: HTTPClientOptions = {}) {
-    this.fetcher = options.fetcher || DEFAULT_FETCHER
+    this.fetcher = options.fetcher || DEFAULT_FETCHER;
   }
 
   async request(request: Request): Promise<Response> {
-    let req = request
+    let req = request;
     for (const hook of this.requestHooks) {
-      const nextRequest = await hook(req)
+      const nextRequest = await hook(req);
       if (nextRequest) {
-        req = nextRequest
+        req = nextRequest;
       }
     }
 
     try {
-      const res = await this.fetcher(req)
+      const res = await this.fetcher(req);
 
       for (const hook of this.responseHooks) {
-        await hook(res, req)
+        await hook(res, req);
       }
 
-      return res
+      return res;
     } catch (err) {
       for (const hook of this.requestErrorHooks) {
-        await hook(err, req)
+        await hook(err, req);
       }
 
-      throw err
+      throw err;
     }
   }
 
@@ -78,17 +81,17 @@ export class HTTPClient {
    * can mutate the request or return a new request. This may be useful to add
    * additional information to request such as request IDs and tracing headers.
    */
-  addHook(hook: "beforeRequest", fn: BeforeRequestHook): this
+  addHook(hook: "beforeRequest", fn: BeforeRequestHook): this;
   /**
    * Registers a hook that is called when a request cannot be made due to a
    * network error.
    */
-  addHook(hook: "requestError", fn: RequestErrorHook): this
+  addHook(hook: "requestError", fn: RequestErrorHook): this;
   /**
    * Registers a hook that is called when a response has been received from the
    * server.
    */
-  addHook(hook: "response", fn: ResponseHook): this
+  addHook(hook: "response", fn: ResponseHook): this;
   addHook(
     ...args:
       | [hook: "beforeRequest", fn: BeforeRequestHook]
@@ -96,86 +99,87 @@ export class HTTPClient {
       | [hook: "response", fn: ResponseHook]
   ) {
     if (args[0] === "beforeRequest") {
-      this.requestHooks.push(args[1])
+      this.requestHooks.push(args[1]);
     } else if (args[0] === "requestError") {
-      this.requestErrorHooks.push(args[1])
+      this.requestErrorHooks.push(args[1]);
     } else if (args[0] === "response") {
-      this.responseHooks.push(args[1])
+      this.responseHooks.push(args[1]);
     } else {
-      throw new Error(`Invalid hook type: ${args[0]}`)
+      throw new Error(`Invalid hook type: ${args[0]}`);
     }
-    return this
+    return this;
   }
 
   /** Removes a hook that was previously registered with `addHook`. */
-  removeHook(hook: "beforeRequest", fn: BeforeRequestHook): this
+  removeHook(hook: "beforeRequest", fn: BeforeRequestHook): this;
   /** Removes a hook that was previously registered with `addHook`. */
-  removeHook(hook: "requestError", fn: RequestErrorHook): this
+  removeHook(hook: "requestError", fn: RequestErrorHook): this;
   /** Removes a hook that was previously registered with `addHook`. */
-  removeHook(hook: "response", fn: ResponseHook): this
+  removeHook(hook: "response", fn: ResponseHook): this;
   removeHook(
     ...args:
       | [hook: "beforeRequest", fn: BeforeRequestHook]
       | [hook: "requestError", fn: RequestErrorHook]
       | [hook: "response", fn: ResponseHook]
   ): this {
-    let target: unknown[]
+    let target: unknown[];
     if (args[0] === "beforeRequest") {
-      target = this.requestHooks
+      target = this.requestHooks;
     } else if (args[0] === "requestError") {
-      target = this.requestErrorHooks
+      target = this.requestErrorHooks;
     } else if (args[0] === "response") {
-      target = this.responseHooks
+      target = this.responseHooks;
     } else {
-      throw new Error(`Invalid hook type: ${args[0]}`)
+      throw new Error(`Invalid hook type: ${args[0]}`);
     }
 
-    const index = target.findIndex(v => v === args[1])
+    const index = target.findIndex((v) => v === args[1]);
     if (index >= 0) {
-      target.splice(index, 1)
+      target.splice(index, 1);
     }
 
-    return this
+    return this;
   }
 
   clone(): HTTPClient {
-    const child = new HTTPClient(this.options)
-    child.requestHooks = this.requestHooks.slice()
-    child.requestErrorHooks = this.requestErrorHooks.slice()
-    child.responseHooks = this.responseHooks.slice()
+    const child = new HTTPClient(this.options);
+    child.requestHooks = this.requestHooks.slice();
+    child.requestErrorHooks = this.requestErrorHooks.slice();
+    child.responseHooks = this.responseHooks.slice();
 
-    return child
+    return child;
   }
 }
 
-export type StatusCodePredicate = number | string | (number | string)[]
+export type StatusCodePredicate = number | string | (number | string)[];
 
 // A semicolon surrounded by optional whitespace characters is used to separate
 // segments in a media type string.
-const mediaParamSeparator = /\s*;\s*/g
+const mediaParamSeparator = /\s*;\s*/g;
 
 export function matchContentType(response: Response, pattern: string): boolean {
   // `*` is a special case which means anything is acceptable.
   if (pattern === "*") {
-    return true
+    return true;
   }
 
-  let contentType = response.headers.get("content-type")?.trim() || "application/octet-stream"
-  contentType = contentType.toLowerCase()
+  let contentType =
+    response.headers.get("content-type")?.trim() || "application/octet-stream";
+  contentType = contentType.toLowerCase();
 
-  const wantParts = pattern.toLowerCase().trim().split(mediaParamSeparator)
-  const [wantType = "", ...wantParams] = wantParts
+  const wantParts = pattern.toLowerCase().trim().split(mediaParamSeparator);
+  const [wantType = "", ...wantParams] = wantParts;
 
   if (wantType.split("/").length !== 2) {
-    return false
+    return false;
   }
 
-  const gotParts = contentType.split(mediaParamSeparator)
-  const [gotType = "", ...gotParams] = gotParts
+  const gotParts = contentType.split(mediaParamSeparator);
+  const [gotType = "", ...gotParams] = gotParts;
 
-  const [type = "", subtype = ""] = gotType.split("/")
+  const [type = "", subtype = ""] = gotType.split("/");
   if (!type || !subtype) {
-    return false
+    return false;
   }
 
   if (
@@ -184,55 +188,58 @@ export function matchContentType(response: Response, pattern: string): boolean {
     `${type}/*` !== wantType &&
     `*/${subtype}` !== wantType
   ) {
-    return false
+    return false;
   }
 
   if (gotParams.length < wantParams.length) {
-    return false
+    return false;
   }
 
-  const params = new Set(gotParams)
+  const params = new Set(gotParams);
   for (const wantParam of wantParams) {
     if (!params.has(wantParam)) {
-      return false
+      return false;
     }
   }
 
-  return true
+  return true;
 }
 
-const codeRangeRE = /^[0-9]xx$/i
+const codeRangeRE = new RegExp("^[0-9]xx$", "i");
 
-export function matchStatusCode(response: Response, codes: StatusCodePredicate): boolean {
-  const actual = `${response.status}`
-  const expectedCodes = Array.isArray(codes) ? codes : [codes]
+export function matchStatusCode(
+  response: Response,
+  codes: StatusCodePredicate,
+): boolean {
+  const actual = `${response.status}`;
+  const expectedCodes = Array.isArray(codes) ? codes : [codes];
   if (!expectedCodes.length) {
-    return false
+    return false;
   }
 
-  return expectedCodes.some(ec => {
-    const code = `${ec}`
+  return expectedCodes.some((ec) => {
+    const code = `${ec}`;
 
     if (code === "default") {
-      return true
+      return true;
     }
 
     if (!codeRangeRE.test(`${code}`)) {
-      return code === actual
+      return code === actual;
     }
 
-    const expectFamily = code.charAt(0)
+    const expectFamily = code.charAt(0);
     if (!expectFamily) {
-      throw new Error("Invalid status code range")
+      throw new Error("Invalid status code range");
     }
 
-    const actualFamily = actual.charAt(0)
+    const actualFamily = actual.charAt(0);
     if (!actualFamily) {
-      throw new Error(`Invalid response status code: ${actual}`)
+      throw new Error(`Invalid response status code: ${actual}`);
     }
 
-    return actualFamily === expectFamily
-  })
+    return actualFamily === expectFamily;
+  });
 }
 
 export function matchResponse(
@@ -240,7 +247,10 @@ export function matchResponse(
   code: StatusCodePredicate,
   contentTypePattern: string,
 ): boolean {
-  return matchStatusCode(response, code) && matchContentType(response, contentTypePattern)
+  return (
+    matchStatusCode(response, code) &&
+    matchContentType(response, contentTypePattern)
+  );
 }
 
 /**
@@ -248,21 +258,26 @@ export function matchResponse(
  */
 export function isConnectionError(err: unknown): boolean {
   if (typeof err !== "object" || err == null) {
-    return false
+    return false;
   }
 
   // Covers fetch in Deno as well
   const isBrowserErr =
-    err instanceof TypeError && err.message.toLowerCase().startsWith("failed to fetch")
+    err instanceof TypeError &&
+    err.message.toLowerCase().startsWith("failed to fetch");
 
-  const isNodeErr = err instanceof TypeError && err.message.toLowerCase().startsWith("fetch failed")
+  const isNodeErr =
+    err instanceof TypeError &&
+    err.message.toLowerCase().startsWith("fetch failed");
 
-  const isBunErr = "name" in err && err.name === "ConnectionError"
+  const isBunErr = "name" in err && err.name === "ConnectionError";
 
   const isGenericErr =
-    "code" in err && typeof err.code === "string" && err.code.toLowerCase() === "econnreset"
+    "code" in err &&
+    typeof err.code === "string" &&
+    err.code.toLowerCase() === "econnreset";
 
-  return isBrowserErr || isNodeErr || isGenericErr || isBunErr
+  return isBrowserErr || isNodeErr || isGenericErr || isBunErr;
 }
 
 /**
@@ -270,18 +285,20 @@ export function isConnectionError(err: unknown): boolean {
  */
 export function isTimeoutError(err: unknown): boolean {
   if (typeof err !== "object" || err == null) {
-    return false
+    return false;
   }
 
   // Fetch in browser, Node.js, Bun, Deno
-  const isNative = "name" in err && err.name === "TimeoutError"
-  const isLegacyNative = "code" in err && err.code === 23
+  const isNative = "name" in err && err.name === "TimeoutError";
+  const isLegacyNative = "code" in err && err.code === 23;
 
   // Node.js HTTP client and Axios
   const isGenericErr =
-    "code" in err && typeof err.code === "string" && err.code.toLowerCase() === "econnaborted"
+    "code" in err &&
+    typeof err.code === "string" &&
+    err.code.toLowerCase() === "econnaborted";
 
-  return isNative || isLegacyNative || isGenericErr
+  return isNative || isLegacyNative || isGenericErr;
 }
 
 /**
@@ -289,16 +306,18 @@ export function isTimeoutError(err: unknown): boolean {
  */
 export function isAbortError(err: unknown): boolean {
   if (typeof err !== "object" || err == null) {
-    return false
+    return false;
   }
 
   // Fetch in browser, Node.js, Bun, Deno
-  const isNative = "name" in err && err.name === "AbortError"
-  const isLegacyNative = "code" in err && err.code === 20
+  const isNative = "name" in err && err.name === "AbortError";
+  const isLegacyNative = "code" in err && err.code === 20;
 
   // Node.js HTTP client and Axios
   const isGenericErr =
-    "code" in err && typeof err.code === "string" && err.code.toLowerCase() === "econnaborted"
+    "code" in err &&
+    typeof err.code === "string" &&
+    err.code.toLowerCase() === "econnaborted";
 
-  return isNative || isLegacyNative || isGenericErr
+  return isNative || isLegacyNative || isGenericErr;
 }

package/src/lib/is-plain-object.ts

@@ -29,15 +29,15 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 export function isPlainObject(value: unknown): value is object {
   if (typeof value !== "object" || value === null) {
-    return false
+    return false;
   }
 
-  const prototype = Object.getPrototypeOf(value)
+  const prototype = Object.getPrototypeOf(value);
   return (
     (prototype === null ||
       prototype === Object.prototype ||
       Object.getPrototypeOf(prototype) === null) &&
     !(Symbol.toStringTag in value) &&
     !(Symbol.iterator in value)
-  )
+  );
 }

package/src/lib/logger.ts

@@ -3,7 +3,7 @@
  */
 
 export interface Logger {
-  group(label?: string): void
-  groupEnd(): void
-  log(message: any, ...args: any[]): void
+  group(label?: string): void;
+  groupEnd(): void;
+  log(message: any, ...args: any[]): void;
 }