gossamer

// src/gossamer/referrer_policy.ts
import * as $rp from "./referrer_policy.mjs";
function toReferrerPolicy(value) {
  if ($rp.ReferrerPolicy$isNoReferrer(value)) return "no-referrer";
  if ($rp.ReferrerPolicy$isNoReferrerWhenDowngrade(value)) {
    return "no-referrer-when-downgrade";
  }
  if ($rp.ReferrerPolicy$isOrigin(value)) return "origin";
  if ($rp.ReferrerPolicy$isOriginWhenCrossOrigin(value)) {
    return "origin-when-cross-origin";
  }
  if ($rp.ReferrerPolicy$isSameOrigin(value)) return "same-origin";
  if ($rp.ReferrerPolicy$isStrictOrigin(value)) return "strict-origin";
  if ($rp.ReferrerPolicy$isUnsafeUrl(value)) return "unsafe-url";
  if ($rp.ReferrerPolicy$isOther(value)) {
    return $rp.ReferrerPolicy$Other$0(value);
  }
  return "strict-origin-when-cross-origin";
}
function fromReferrerPolicy(value) {
  switch (value) {
    case "no-referrer":
      return $rp.ReferrerPolicy$NoReferrer();
    case "no-referrer-when-downgrade":
      return $rp.ReferrerPolicy$NoReferrerWhenDowngrade();
    case "origin":
      return $rp.ReferrerPolicy$Origin();
    case "origin-when-cross-origin":
      return $rp.ReferrerPolicy$OriginWhenCrossOrigin();
    case "same-origin":
      return $rp.ReferrerPolicy$SameOrigin();
    case "strict-origin":
      return $rp.ReferrerPolicy$StrictOrigin();
    case "strict-origin-when-cross-origin":
      return $rp.ReferrerPolicy$StrictOriginWhenCrossOrigin();
    case "unsafe-url":
      return $rp.ReferrerPolicy$UnsafeUrl();
    default:
      return $rp.ReferrerPolicy$Other(value);
  }
}

// src/gossamer/request_cache.ts
import * as $requestCache from "./request_cache.mjs";
function toRequestCache(value) {
  if ($requestCache.RequestCache$isForceCache(value)) return "force-cache";
  if ($requestCache.RequestCache$isNoCache(value)) return "no-cache";
  if ($requestCache.RequestCache$isNoStore(value)) return "no-store";
  if ($requestCache.RequestCache$isOnlyIfCached(value)) return "only-if-cached";
  if ($requestCache.RequestCache$isReload(value)) return "reload";
  if ($requestCache.RequestCache$isOther(value)) {
    return $requestCache.RequestCache$Other$0(value);
  }
  return "default";
}
function fromRequestCache(value) {
  switch (value) {
    case "force-cache":
      return $requestCache.RequestCache$ForceCache();
    case "no-cache":
      return $requestCache.RequestCache$NoCache();
    case "no-store":
      return $requestCache.RequestCache$NoStore();
    case "only-if-cached":
      return $requestCache.RequestCache$OnlyIfCached();
    case "reload":
      return $requestCache.RequestCache$Reload();
    case "default":
      return $requestCache.RequestCache$Default();
    default:
      return $requestCache.RequestCache$Other(value);
  }
}

// src/gossamer/http_method.ts
import * as $hm from "./http_method.mjs";
function toHttpMethod(value) {
  if ($hm.HttpMethod$isConnect(value)) return "CONNECT";
  if ($hm.HttpMethod$isDelete(value)) return "DELETE";
  if ($hm.HttpMethod$isGet(value)) return "GET";
  if ($hm.HttpMethod$isHead(value)) return "HEAD";
  if ($hm.HttpMethod$isOptions(value)) return "OPTIONS";
  if ($hm.HttpMethod$isPatch(value)) return "PATCH";
  if ($hm.HttpMethod$isPost(value)) return "POST";
  if ($hm.HttpMethod$isPut(value)) return "PUT";
  if ($hm.HttpMethod$isOther(value)) return $hm.HttpMethod$Other$0(value);
  return "TRACE";
}
function fromHttpMethod(value) {
  switch (value.toUpperCase()) {
    case "CONNECT":
      return $hm.HttpMethod$Connect();
    case "DELETE":
      return $hm.HttpMethod$Delete();
    case "GET":
      return $hm.HttpMethod$Get();
    case "HEAD":
      return $hm.HttpMethod$Head();
    case "OPTIONS":
      return $hm.HttpMethod$Options();
    case "PATCH":
      return $hm.HttpMethod$Patch();
    case "POST":
      return $hm.HttpMethod$Post();
    case "PUT":
      return $hm.HttpMethod$Put();
    case "TRACE":
      return $hm.HttpMethod$Trace();
    default:
      return $hm.HttpMethod$Other(value);
  }
}

// src/gossamer/request_credentials.ts
import * as $rc from "./request_credentials.mjs";
function toRequestCredentials(value) {
  if ($rc.RequestCredentials$isInclude(value)) return "include";
  if ($rc.RequestCredentials$isOmit(value)) return "omit";
  if ($rc.RequestCredentials$isOther(value)) {
    return $rc.RequestCredentials$Other$0(value);
  }
  return "same-origin";
}
function fromRequestCredentials(value) {
  switch (value) {
    case "include":
      return $rc.RequestCredentials$Include();
    case "omit":
      return $rc.RequestCredentials$Omit();
    case "same-origin":
      return $rc.RequestCredentials$SameOrigin();
    default:
      return $rc.RequestCredentials$Other(value);
  }
}

// src/gossamer/request_destination.ts
import * as $rd from "./request_destination.mjs";
function fromRequestDestination(value) {
  switch (value) {
    case "audio":
      return $rd.RequestDestination$Audio();
    case "audioworklet":
      return $rd.RequestDestination$AudioWorklet();
    case "document":
      return $rd.RequestDestination$Document();
    case "embed":
      return $rd.RequestDestination$Embed();
    case "":
      return $rd.RequestDestination$Empty();
    case "font":
      return $rd.RequestDestination$Font();
    case "frame":
      return $rd.RequestDestination$Frame();
    case "iframe":
      return $rd.RequestDestination$Iframe();
    case "image":
      return $rd.RequestDestination$Image();
    case "json":
      return $rd.RequestDestination$Json();
    case "manifest":
      return $rd.RequestDestination$Manifest();
    case "object":
      return $rd.RequestDestination$Object();
    case "paintworklet":
      return $rd.RequestDestination$PaintWorklet();
    case "report":
      return $rd.RequestDestination$Report();
    case "script":
      return $rd.RequestDestination$Script();
    case "sharedworker":
      return $rd.RequestDestination$SharedWorker();
    case "style":
      return $rd.RequestDestination$Style();
    case "track":
      return $rd.RequestDestination$Track();
    case "video":
      return $rd.RequestDestination$Video();
    case "worker":
      return $rd.RequestDestination$Worker();
    case "xslt":
      return $rd.RequestDestination$Xslt();
    default:
      return $rd.RequestDestination$Other(value);
  }
}

// src/gossamer/request_init.ts
import * as $requestInit from "./request_init.mjs";

// src/gossamer/request_mode.ts
import * as $requestMode from "./request_mode.mjs";
function toRequestMode(value) {
  if ($requestMode.RequestMode$isNavigate(value)) return "navigate";
  if ($requestMode.RequestMode$isNoCors(value)) return "no-cors";
  if ($requestMode.RequestMode$isSameOrigin(value)) return "same-origin";
  if ($requestMode.RequestMode$isOther(value)) {
    return $requestMode.RequestMode$Other$0(value);
  }
  return "cors";
}
function fromRequestMode(value) {
  switch (value) {
    case "navigate":
      return $requestMode.RequestMode$Navigate();
    case "no-cors":
      return $requestMode.RequestMode$NoCors();
    case "same-origin":
      return $requestMode.RequestMode$SameOrigin();
    case "cors":
      return $requestMode.RequestMode$Cors();
    default:
      return $requestMode.RequestMode$Other(value);
  }
}

// src/gossamer/request_redirect.ts
import * as $rr from "./request_redirect.mjs";
function fromRequestRedirect(value) {
  switch (value) {
    case "error":
      return $rr.RequestRedirect$Error();
    case "manual":
      return $rr.RequestRedirect$Manual();
    case "follow":
      return $rr.RequestRedirect$Follow();
    default:
      return $rr.RequestRedirect$Other(value);
  }
}
function toRequestRedirect(value) {
  if ($rr.RequestRedirect$isError(value)) return "error";
  if ($rr.RequestRedirect$isManual(value)) return "manual";
  if ($rr.RequestRedirect$isOther(value)) {
    return $rr.RequestRedirect$Other$0(value);
  }
  return "follow";
}

// src/gossamer/request_init.ts
function toRequestInit(options) {
  const result = {};
  for (const option of options) {
    if ($requestInit.RequestInit$isMethod(option)) {
      result.method = toHttpMethod($requestInit.RequestInit$Method$0(option));
    } else if ($requestInit.RequestInit$isHeaders(option)) {
      result.headers = $requestInit.RequestInit$Headers$0(option);
    } else if ($requestInit.RequestInit$isBody(option)) {
      result.body = $requestInit.RequestInit$Body$0(option);
    } else if ($requestInit.RequestInit$isCache(option)) {
      result.cache = toRequestCache(
        $requestInit.RequestInit$Cache$0(option)
      );
    } else if ($requestInit.RequestInit$isCredentials(option)) {
      result.credentials = toRequestCredentials(
        $requestInit.RequestInit$Credentials$0(option)
      );
    } else if ($requestInit.RequestInit$isIntegrity(option)) {
      result.integrity = $requestInit.RequestInit$Integrity$0(option);
    } else if ($requestInit.RequestInit$isKeepalive(option)) {
      result.keepalive = $requestInit.RequestInit$Keepalive$0(option);
    } else if ($requestInit.RequestInit$isMode(option)) {
      result.mode = toRequestMode(
        $requestInit.RequestInit$Mode$0(option)
      );
    } else if ($requestInit.RequestInit$isRedirect(option)) {
      result.redirect = toRequestRedirect(
        $requestInit.RequestInit$Redirect$0(option)
      );
    } else if ($requestInit.RequestInit$isReferrer(option)) {
      result.referrer = $requestInit.RequestInit$Referrer$0(option);
    } else if ($requestInit.RequestInit$isReferrerPolicy(option)) {
      result.referrerPolicy = toReferrerPolicy(
        $requestInit.RequestInit$ReferrerPolicy$0(option)
      );
    } else if ($requestInit.RequestInit$isSignal(option)) {
      result.signal = $requestInit.RequestInit$Signal$0(option);
    }
  }
  return result;
}

// src/utils/list.ts
import {
  List$Empty,
  List$isNonEmpty,
  List$NonEmpty,
  List$NonEmpty$first,
  List$NonEmpty$rest
} from "../../prelude.mjs";
function toArray(list) {
  const array = [];
  let current = list;
  while (List$isNonEmpty(current)) {
    array.push(List$NonEmpty$first(current));
    current = List$NonEmpty$rest(current);
  }
  return array;
}

// src/utils/result.ts
import { Result$Error, Result$Ok } from "../../prelude.mjs";
function toResult(value) {
  return value === null || value === void 0 ? Result$Error(void 0) : Result$Ok(value);
}
toResult.fromThrows = function(throws) {
  try {
    return Result$Ok(throws());
  } catch (error) {
    return Result$Error(
      error instanceof Error ? error.message : String(error)
    );
  }
};
toResult.fromPromise = function(promise) {
  return promise.then(
    (value) => Result$Ok(value),
    (error) => Result$Error(error instanceof Error ? error.message : String(error))
  );
};

// src/gossamer/request.ffi.ts
var new_ = (input) => {
  return toResult.fromThrows(() => new Request(input));
};
var new_with_init = (input, init) => {
  return toResult.fromThrows(
    () => new Request(input, toRequestInit(toArray(init)))
  );
};
var method = (request) => {
  return fromHttpMethod(request.method);
};
var url = (request) => request.url;
var headers = (request) => request.headers;
var cache = (request) => {
  return fromRequestCache(request.cache);
};
var credentials = (request) => {
  return fromRequestCredentials(request.credentials);
};
var destination = (request) => {
  return fromRequestDestination(request.destination);
};
var redirect = (request) => {
  return fromRequestRedirect(request.redirect);
};
var signal = (request) => request.signal;
var referrer = (request) => request.referrer;
var referrer_policy = (request) => {
  return fromReferrerPolicy(request.referrerPolicy);
};
var mode = (request) => {
  return fromRequestMode(request.mode);
};
var is_keepalive = (request) => {
  return request.keepalive;
};
var integrity = (request) => {
  return request.integrity;
};
var clone = (request) => request.clone();
var body = (request) => {
  return toResult(request.body);
};
var is_body_used = (request) => {
  return request.bodyUsed;
};
var blob = (request) => {
  return toResult.fromPromise(request.blob());
};
var array_buffer = (request) => {
  return toResult.fromPromise(request.arrayBuffer());
};
var bytes = (request) => {
  return toResult.fromPromise(request.bytes());
};
var json = (request) => {
  return toResult.fromPromise(request.json());
};
var form_data = (request) => {
  return toResult.fromPromise(request.formData());
};
var text = (request) => {
  return toResult.fromPromise(request.text());
};
export {
  array_buffer,
  blob,
  body,
  bytes,
  cache,
  clone,
  credentials,
  destination,
  form_data,
  headers,
  integrity,
  is_body_used,
  is_keepalive,
  json,
  method,
  mode,
  new_,
  new_with_init,
  redirect,
  referrer,
  referrer_policy,
  signal,
  text,
  url
};