tanstack_start_ts 1.0.0

package/dist/server/assets/vendor-supabase-functions-js-sWy4UYn1.js

@@ -0,0 +1,322 @@
+import { a as __awaiter } from "./vendor-tslib-_8ICaZ64.js";
+const resolveFetch = (customFetch) => {
+  if (customFetch) {
+    return (...args) => customFetch(...args);
+  }
+  return (...args) => fetch(...args);
+};
+class FunctionsError extends Error {
+  constructor(message, name = "FunctionsError", context) {
+    super(message);
+    this.name = name;
+    this.context = context;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      context: this.context
+    };
+  }
+}
+class FunctionsFetchError extends FunctionsError {
+  constructor(context) {
+    super("Failed to send a request to the Edge Function", "FunctionsFetchError", context);
+  }
+}
+class FunctionsRelayError extends FunctionsError {
+  constructor(context) {
+    super("Relay Error invoking the Edge Function", "FunctionsRelayError", context);
+  }
+}
+class FunctionsHttpError extends FunctionsError {
+  constructor(context) {
+    super("Edge Function returned a non-2xx status code", "FunctionsHttpError", context);
+  }
+}
+var FunctionRegion;
+(function(FunctionRegion2) {
+  FunctionRegion2["Any"] = "any";
+  FunctionRegion2["ApNortheast1"] = "ap-northeast-1";
+  FunctionRegion2["ApNortheast2"] = "ap-northeast-2";
+  FunctionRegion2["ApSouth1"] = "ap-south-1";
+  FunctionRegion2["ApSoutheast1"] = "ap-southeast-1";
+  FunctionRegion2["ApSoutheast2"] = "ap-southeast-2";
+  FunctionRegion2["CaCentral1"] = "ca-central-1";
+  FunctionRegion2["EuCentral1"] = "eu-central-1";
+  FunctionRegion2["EuWest1"] = "eu-west-1";
+  FunctionRegion2["EuWest2"] = "eu-west-2";
+  FunctionRegion2["EuWest3"] = "eu-west-3";
+  FunctionRegion2["SaEast1"] = "sa-east-1";
+  FunctionRegion2["UsEast1"] = "us-east-1";
+  FunctionRegion2["UsWest1"] = "us-west-1";
+  FunctionRegion2["UsWest2"] = "us-west-2";
+})(FunctionRegion || (FunctionRegion = {}));
+class FunctionsClient {
+  /**
+   * Creates a new Functions client bound to an Edge Functions URL.
+   *
+   * @example Using supabase-js (recommended)
+   * ```ts
+   * import { createClient } from '@supabase/supabase-js'
+   *
+   * const supabase = createClient('https://xyzcompany.supabase.co', 'your-publishable-key')
+   * const { data, error } = await supabase.functions.invoke('hello-world')
+   * ```
+   *
+   * @category Edge Functions
+   *
+   * @example Standalone import for bundle-sensitive environments
+   * ```ts
+   * import { FunctionsClient, FunctionRegion } from '@supabase/functions-js'
+   *
+   * const functions = new FunctionsClient('https://xyzcompany.supabase.co/functions/v1', {
+   *   headers: { apikey: 'your-publishable-key' },
+   *   region: FunctionRegion.UsEast1,
+   * })
+   * ```
+   */
+  constructor(url, { headers = {}, customFetch, region = FunctionRegion.Any } = {}) {
+    this.url = url;
+    this.headers = headers;
+    this.region = region;
+    this.fetch = resolveFetch(customFetch);
+  }
+  /**
+   * Updates the authorization header
+   * @param token - the new jwt token sent in the authorisation header
+   *
+   * @category Edge Functions
+   *
+   * @example Setting the authorization header
+   * ```ts
+   * functions.setAuth(session.access_token)
+   * ```
+   */
+  setAuth(token) {
+    this.headers.Authorization = `Bearer ${token}`;
+  }
+  /**
+   * Invokes a function
+   * @param functionName - The name of the Function to invoke.
+   * @param options - Options for invoking the Function.
+   * @example
+   * ```ts
+   * const { data, error } = await functions.invoke('hello-world', {
+   *   body: { name: 'Ada' },
+   * })
+   * ```
+   *
+   * @category Edge Functions
+   *
+   * @remarks
+   * - Requires an Authorization header.
+   * - Invoke params generally match the [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API) spec.
+   * - When you pass in a body to your function, we automatically attach the Content-Type header for `Blob`, `ArrayBuffer`, `File`, `FormData` and `String`. If it doesn't match any of these types we assume the payload is `json`, serialize it and attach the `Content-Type` header as `application/json`. You can override this behavior by passing in a `Content-Type` header of your own.
+   * - Responses are automatically parsed as `json`, `blob` and `form-data` depending on the `Content-Type` header sent by your function. Responses are parsed as `text` by default.
+   *
+   * @example Basic invocation
+   * ```js
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   body: { foo: 'bar' }
+   * })
+   * ```
+   *
+   * @exampleDescription Error handling
+   * A `FunctionsHttpError` error is returned if your function throws an error, `FunctionsRelayError` if the Supabase Relay has an error processing your function and `FunctionsFetchError` if there is a network error in calling your function.
+   *
+   * @example Error handling
+   * ```js
+   * import { FunctionsHttpError, FunctionsRelayError, FunctionsFetchError } from "@supabase/supabase-js";
+   *
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   headers: {
+   *     "my-custom-header": 'my-custom-header-value'
+   *   },
+   *   body: { foo: 'bar' }
+   * })
+   *
+   * if (error instanceof FunctionsHttpError) {
+   *   const errorMessage = await error.context.json()
+   *   console.log('Function returned an error', errorMessage)
+   * } else if (error instanceof FunctionsRelayError) {
+   *   console.log('Relay error:', error.message)
+   * } else if (error instanceof FunctionsFetchError) {
+   *   console.log('Fetch error:', error.message)
+   * }
+   * ```
+   *
+   * @exampleDescription Passing custom headers
+   * You can pass custom headers to your function. Note: supabase-js automatically passes the `Authorization` header with the signed in user's JWT.
+   *
+   * @example Passing custom headers
+   * ```js
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   headers: {
+   *     "my-custom-header": 'my-custom-header-value'
+   *   },
+   *   body: { foo: 'bar' }
+   * })
+   * ```
+   *
+   * @exampleDescription Calling with DELETE HTTP verb
+   * You can also set the HTTP verb to `DELETE` when calling your Edge Function.
+   *
+   * @example Calling with DELETE HTTP verb
+   * ```js
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   headers: {
+   *     "my-custom-header": 'my-custom-header-value'
+   *   },
+   *   body: { foo: 'bar' },
+   *   method: 'DELETE'
+   * })
+   * ```
+   *
+   * @exampleDescription Invoking a Function in the UsEast1 region
+   * Here are the available regions:
+   * - `FunctionRegion.Any`
+   * - `FunctionRegion.ApNortheast1`
+   * - `FunctionRegion.ApNortheast2`
+   * - `FunctionRegion.ApSouth1`
+   * - `FunctionRegion.ApSoutheast1`
+   * - `FunctionRegion.ApSoutheast2`
+   * - `FunctionRegion.CaCentral1`
+   * - `FunctionRegion.EuCentral1`
+   * - `FunctionRegion.EuWest1`
+   * - `FunctionRegion.EuWest2`
+   * - `FunctionRegion.EuWest3`
+   * - `FunctionRegion.SaEast1`
+   * - `FunctionRegion.UsEast1`
+   * - `FunctionRegion.UsWest1`
+   * - `FunctionRegion.UsWest2`
+   *
+   * @example Invoking a Function in the UsEast1 region
+   * ```js
+   * import { createClient, FunctionRegion } from '@supabase/supabase-js'
+   *
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   body: { foo: 'bar' },
+   *   region: FunctionRegion.UsEast1
+   * })
+   * ```
+   *
+   * @exampleDescription Calling with GET HTTP verb
+   * You can also set the HTTP verb to `GET` when calling your Edge Function.
+   *
+   * @example Calling with GET HTTP verb
+   * ```js
+   * const { data, error } = await supabase.functions.invoke('hello', {
+   *   headers: {
+   *     "my-custom-header": 'my-custom-header-value'
+   *   },
+   *   method: 'GET'
+   * })
+   * ```
+   *
+   * @example Standalone client invoke
+   * ```ts
+   * const { data, error } = await functions.invoke('hello-world', {
+   *   body: { name: 'Ada' },
+   * })
+   * ```
+   */
+  invoke(functionName_1) {
+    return __awaiter(this, arguments, void 0, function* (functionName, options = {}) {
+      var _a;
+      let timeoutId;
+      let timeoutController;
+      try {
+        const { headers, method, body: functionArgs, signal, timeout } = options;
+        let _headers = {};
+        let { region } = options;
+        if (!region) {
+          region = this.region;
+        }
+        const url = new URL(`${this.url}/${functionName}`);
+        if (region && region !== "any") {
+          _headers["x-region"] = region;
+          url.searchParams.set("forceFunctionRegion", region);
+        }
+        let body;
+        if (functionArgs && (headers && !Object.prototype.hasOwnProperty.call(headers, "Content-Type") || !headers)) {
+          if (typeof Blob !== "undefined" && functionArgs instanceof Blob || functionArgs instanceof ArrayBuffer) {
+            _headers["Content-Type"] = "application/octet-stream";
+            body = functionArgs;
+          } else if (typeof functionArgs === "string") {
+            _headers["Content-Type"] = "text/plain";
+            body = functionArgs;
+          } else if (typeof FormData !== "undefined" && functionArgs instanceof FormData) {
+            body = functionArgs;
+          } else {
+            _headers["Content-Type"] = "application/json";
+            body = JSON.stringify(functionArgs);
+          }
+        } else {
+          if (functionArgs && typeof functionArgs !== "string" && !(typeof Blob !== "undefined" && functionArgs instanceof Blob) && !(functionArgs instanceof ArrayBuffer) && !(typeof FormData !== "undefined" && functionArgs instanceof FormData)) {
+            body = JSON.stringify(functionArgs);
+          } else {
+            body = functionArgs;
+          }
+        }
+        let effectiveSignal = signal;
+        if (timeout) {
+          timeoutController = new AbortController();
+          timeoutId = setTimeout(() => timeoutController.abort(), timeout);
+          if (signal) {
+            effectiveSignal = timeoutController.signal;
+            signal.addEventListener("abort", () => timeoutController.abort());
+          } else {
+            effectiveSignal = timeoutController.signal;
+          }
+        }
+        const response = yield this.fetch(url.toString(), {
+          method: method || "POST",
+          // headers priority is (high to low):
+          // 1. invoke-level headers
+          // 2. client-level headers
+          // 3. default Content-Type header
+          headers: Object.assign(Object.assign(Object.assign({}, _headers), this.headers), headers),
+          body,
+          signal: effectiveSignal
+        }).catch((fetchError) => {
+          throw new FunctionsFetchError(fetchError);
+        });
+        const isRelayError = response.headers.get("x-relay-error");
+        if (isRelayError && isRelayError === "true") {
+          throw new FunctionsRelayError(response);
+        }
+        if (!response.ok) {
+          throw new FunctionsHttpError(response);
+        }
+        let responseType = ((_a = response.headers.get("Content-Type")) !== null && _a !== void 0 ? _a : "text/plain").split(";")[0].trim();
+        let data;
+        if (responseType === "application/json") {
+          data = yield response.json();
+        } else if (responseType === "application/octet-stream" || responseType === "application/pdf") {
+          data = yield response.blob();
+        } else if (responseType === "text/event-stream") {
+          data = response;
+        } else if (responseType === "multipart/form-data") {
+          data = yield response.formData();
+        } else {
+          data = yield response.text();
+        }
+        return { data, error: null, response };
+      } catch (error) {
+        return {
+          data: null,
+          error,
+          response: error instanceof FunctionsHttpError || error instanceof FunctionsRelayError ? error.context : void 0
+        };
+      } finally {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+      }
+    });
+  }
+}
+export {
+  FunctionsClient as F
+};