@fluid-app/fluid-cli-theme-dev 0.1.58 → 0.1.60

package/dist/dist-cli-preview/chunks/client.gen-CSTBgfxj.js

@@ -0,0 +1,672 @@
+var X = Object.defineProperty;
+var Y = (t, e, r) => e in t ? X(t, e, { enumerable: !0, configurable: !0, writable: !0, value: r }) : t[e] = r;
+var D = (t, e, r) => Y(t, typeof e != "symbol" ? e + "" : e, r);
+import { aA as A, az as Z, ad as C } from "./account-screen-runtime-DxhJm6Qd.js";
+function j(t) {
+  if (typeof t != "string")
+    return;
+  const e = t.trim();
+  return e.length > 0 ? e : void 0;
+}
+function P(t, e) {
+  const r = C(e?.meta);
+  return j(t.headers.get("x-request-id")) ?? j(t.headers.get("request-id")) ?? j(e?.request_id) ?? j(e?.requestId) ?? j(r?.request_id) ?? j(r?.requestId);
+}
+function ee(t, e) {
+  const r = C(t.error);
+  return j(t.message) ?? j(t.error_message) ?? j(r?.message) ?? e;
+}
+function Se(t = {}) {
+  return (e, r, n, o) => {
+    if (!r)
+      return e instanceof A || t.shouldPassThroughTransportError?.(e) || !n ? e : new A(
+        `Network error: ${e instanceof Error ? e.message : "Unknown network error"}`,
+        0,
+        null
+      );
+    if (r.ok && e instanceof SyntaxError)
+      return new A(
+        "Failed to parse response as JSON",
+        r.status,
+        null,
+        P(r, null)
+      );
+    t.onResponseError?.(r);
+    const c = n?.method ?? o.method ?? "GET", s = C(e), a = P(r, s);
+    if (s)
+      return new A(
+        ee(s, `${c} request failed`),
+        r.status,
+        Z(s),
+        a,
+        s
+      );
+    const i = r.headers.get("content-type")?.includes("application/json"), p = j(e);
+    return new A(
+      i && p ? p.slice(0, 200) : `${c} request failed with status ${r.status}`,
+      r.status,
+      // A parsed JSON string is a legal `ApiErrorData` member, so it is kept
+      // rather than dropped — the shared fetch client already preserves it, and
+      // discarding it here made the two producers disagree.
+      i ? e : null,
+      a,
+      // Unreachable as an envelope: this branch runs only when the payload is
+      // not a plain object, which is exactly what `toApiErrorBody` rejects.
+      null
+    );
+  };
+}
+const te = {
+  bodySerializer: (t) => JSON.stringify(
+    t,
+    (e, r) => typeof r == "bigint" ? r.toString() : r
+  )
+};
+function re({
+  onRequest: t,
+  onSseError: e,
+  onSseEvent: r,
+  responseTransformer: n,
+  responseValidator: o,
+  sseDefaultRetryDelay: c,
+  sseMaxRetryAttempts: s,
+  sseMaxRetryDelay: a,
+  sseSleepFn: i,
+  url: p,
+  ...u
+}) {
+  let l;
+  const g = i ?? ((d) => new Promise((h) => setTimeout(h, d)));
+  return { stream: async function* () {
+    let d = c ?? 3e3, h = 0;
+    const w = u.signal ?? new AbortController().signal;
+    for (; !w.aborted; ) {
+      h++;
+      const O = u.headers instanceof Headers ? u.headers : new Headers(u.headers);
+      l !== void 0 && O.set("Last-Event-ID", l);
+      try {
+        const x = {
+          redirect: "follow",
+          ...u,
+          body: u.serializedBody,
+          headers: O,
+          signal: w
+        };
+        let q = new Request(p, x);
+        t && (q = await t(p, x));
+        const y = await (u.fetch ?? globalThis.fetch)(q);
+        if (!y.ok)
+          throw new Error(
+            `SSE failed: ${y.status} ${y.statusText}`
+          );
+        if (!y.body) throw new Error("No body in SSE response");
+        const S = y.body.pipeThrough(new TextDecoderStream()).getReader();
+        let b = "";
+        const v = () => {
+          try {
+            S.cancel();
+          } catch {
+          }
+        };
+        w.addEventListener("abort", v);
+        try {
+          for (; ; ) {
+            const { done: G, value: M } = await S.read();
+            if (G) break;
+            b += M, b = b.replace(/\r\n?/g, `
+`);
+            const B = b.split(`
+
+`);
+            b = B.pop() ?? "";
+            for (const Q of B) {
+              const K = Q.split(`
+`), k = [];
+              let N;
+              for (const E of K)
+                if (E.startsWith("data:"))
+                  k.push(E.replace(/^data:\s*/, ""));
+                else if (E.startsWith("event:"))
+                  N = E.replace(/^event:\s*/, "");
+                else if (E.startsWith("id:"))
+                  l = E.replace(/^id:\s*/, "");
+                else if (E.startsWith("retry:")) {
+                  const U = Number.parseInt(
+                    E.replace(/^retry:\s*/, ""),
+                    10
+                  );
+                  Number.isNaN(U) || (d = U);
+                }
+              let z, R = !1;
+              if (k.length) {
+                const E = k.join(`
+`);
+                try {
+                  z = JSON.parse(E), R = !0;
+                } catch {
+                  z = E;
+                }
+              }
+              R && (o && await o(z), n && (z = await n(z))), r?.({
+                data: z,
+                event: N,
+                id: l,
+                retry: d
+              }), k.length && (yield z);
+            }
+          }
+        } finally {
+          w.removeEventListener("abort", v), S.releaseLock();
+        }
+        break;
+      } catch (x) {
+        if (e?.(x), s !== void 0 && h >= s)
+          break;
+        const q = Math.min(
+          d * 2 ** (h - 1),
+          a ?? 3e4
+        );
+        await g(q);
+      }
+    }
+  }() };
+}
+const se = (t) => {
+  switch (t) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+}, ae = (t) => {
+  switch (t) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+}, ne = (t) => {
+  switch (t) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+}, _ = ({
+  allowReserved: t,
+  explode: e,
+  name: r,
+  style: n,
+  value: o
+}) => {
+  if (!e) {
+    const a = (t ? o : o.map((i) => encodeURIComponent(i))).join(ae(n));
+    switch (n) {
+      case "label":
+        return `.${a}`;
+      case "matrix":
+        return `;${r}=${a}`;
+      case "simple":
+        return a;
+      default:
+        return `${r}=${a}`;
+    }
+  }
+  const c = se(n), s = o.map((a) => n === "label" || n === "simple" ? t ? a : encodeURIComponent(a) : $({
+    allowReserved: t,
+    name: r,
+    value: a
+  })).join(c);
+  return n === "label" || n === "matrix" ? c + s : s;
+}, $ = ({
+  allowReserved: t,
+  name: e,
+  value: r
+}) => {
+  if (r == null)
+    return "";
+  if (typeof r == "object")
+    throw new Error(
+      "Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these."
+    );
+  return `${e}=${t ? r : encodeURIComponent(r)}`;
+}, J = ({
+  allowReserved: t,
+  explode: e,
+  name: r,
+  style: n,
+  value: o,
+  valueOnly: c
+}) => {
+  if (o instanceof Date)
+    return c ? o.toISOString() : `${r}=${o.toISOString()}`;
+  if (n !== "deepObject" && !e) {
+    let i = [];
+    Object.entries(o).forEach(([u, l]) => {
+      i = [
+        ...i,
+        u,
+        t ? l : encodeURIComponent(l)
+      ];
+    });
+    const p = i.join(",");
+    switch (n) {
+      case "form":
+        return `${r}=${p}`;
+      case "label":
+        return `.${p}`;
+      case "matrix":
+        return `;${r}=${p}`;
+      default:
+        return p;
+    }
+  }
+  const s = ne(n), a = Object.entries(o).map(
+    ([i, p]) => $({
+      allowReserved: t,
+      name: n === "deepObject" ? `${r}[${i}]` : i,
+      value: p
+    })
+  ).join(s);
+  return n === "label" || n === "matrix" ? s + a : a;
+}, ie = /\{[^{}]+\}/g, oe = ({
+  path: t,
+  url: e
+}) => {
+  let r = e;
+  const n = e.match(ie);
+  if (n)
+    for (const o of n) {
+      let c = !1, s = o.substring(1, o.length - 1), a = "simple";
+      s.endsWith("*") && (c = !0, s = s.substring(0, s.length - 1)), s.startsWith(".") ? (s = s.substring(1), a = "label") : s.startsWith(";") && (s = s.substring(1), a = "matrix");
+      const i = t[s];
+      if (i == null)
+        continue;
+      if (Array.isArray(i)) {
+        r = r.replace(
+          o,
+          _({ explode: c, name: s, style: a, value: i })
+        );
+        continue;
+      }
+      if (typeof i == "object") {
+        r = r.replace(
+          o,
+          J({
+            explode: c,
+            name: s,
+            style: a,
+            value: i,
+            valueOnly: !0
+          })
+        );
+        continue;
+      }
+      if (a === "matrix") {
+        r = r.replace(
+          o,
+          `;${$({
+            name: s,
+            value: i
+          })}`
+        );
+        continue;
+      }
+      const p = encodeURIComponent(
+        a === "label" ? `.${i}` : i
+      );
+      r = r.replace(o, p);
+    }
+  return r;
+}, ce = ({
+  baseUrl: t,
+  path: e,
+  query: r,
+  querySerializer: n,
+  url: o
+}) => {
+  const c = o.startsWith("/") ? o : `/${o}`;
+  let s = (t ?? "") + c;
+  e && (s = oe({ path: e, url: s }));
+  let a = r ? n(r) : "";
+  return a.startsWith("?") && (a = a.substring(1)), a && (s += `?${a}`), s;
+};
+function H(t) {
+  const e = t.body !== void 0;
+  if (e && t.bodySerializer)
+    return "serializedBody" in t ? t.serializedBody !== void 0 && t.serializedBody !== "" ? t.serializedBody : null : t.body !== "" ? t.body : null;
+  if (e)
+    return t.body;
+}
+const le = async (t, e) => {
+  const r = typeof e == "function" ? await e(t) : e;
+  if (r)
+    return t.scheme === "bearer" ? `Bearer ${r}` : t.scheme === "basic" ? `Basic ${btoa(r)}` : r;
+}, L = ({
+  parameters: t = {},
+  ...e
+} = {}) => (n) => {
+  const o = [];
+  if (n && typeof n == "object")
+    for (const c in n) {
+      const s = n[c];
+      if (s == null)
+        continue;
+      const a = t[c] || e;
+      if (Array.isArray(s)) {
+        const i = _({
+          allowReserved: a.allowReserved,
+          explode: !0,
+          name: c,
+          style: "form",
+          value: s,
+          ...a.array
+        });
+        i && o.push(i);
+      } else if (typeof s == "object") {
+        const i = J({
+          allowReserved: a.allowReserved,
+          explode: !0,
+          name: c,
+          style: "deepObject",
+          value: s,
+          ...a.object
+        });
+        i && o.push(i);
+      } else {
+        const i = $({
+          allowReserved: a.allowReserved,
+          name: c,
+          value: s
+        });
+        i && o.push(i);
+      }
+    }
+  return o.join("&");
+}, ue = (t) => {
+  if (!t)
+    return "stream";
+  const e = t.split(";")[0]?.trim();
+  if (e) {
+    if (e.startsWith("application/json") || e.endsWith("+json"))
+      return "json";
+    if (e === "multipart/form-data")
+      return "formData";
+    if (["application/", "audio/", "image/", "video/"].some(
+      (r) => e.startsWith(r)
+    ))
+      return "blob";
+    if (e.startsWith("text/"))
+      return "text";
+  }
+}, de = (t, e) => e ? !!(t.headers.has(e) || t.query?.[e] || t.headers.get("Cookie")?.includes(`${e}=`)) : !1;
+async function fe(t) {
+  for (const e of t.security ?? []) {
+    if (de(t, e.name))
+      continue;
+    const r = await le(e, t.auth);
+    if (!r)
+      continue;
+    const n = e.name ?? "Authorization";
+    switch (e.in) {
+      case "query":
+        t.query || (t.query = {}), t.query[n] = r;
+        break;
+      case "cookie":
+        t.headers.append("Cookie", `${n}=${r}`);
+        break;
+      case "header":
+      default:
+        t.headers.set(n, r);
+        break;
+    }
+  }
+}
+const W = (t) => ce({
+  baseUrl: t.baseUrl,
+  path: t.path,
+  query: t.query,
+  querySerializer: typeof t.querySerializer == "function" ? t.querySerializer : L(t.querySerializer),
+  url: t.url
+}), V = (t, e) => {
+  const r = { ...t, ...e };
+  return r.baseUrl?.endsWith("/") && (r.baseUrl = r.baseUrl.substring(0, r.baseUrl.length - 1)), r.headers = F(t.headers, e.headers), r;
+}, he = (t) => {
+  const e = [];
+  return t.forEach((r, n) => {
+    e.push([n, r]);
+  }), e;
+}, F = (...t) => {
+  const e = new Headers();
+  for (const r of t) {
+    if (!r)
+      continue;
+    const n = r instanceof Headers ? he(r) : Object.entries(r);
+    for (const [o, c] of n)
+      if (c === null)
+        e.delete(o);
+      else if (Array.isArray(c))
+        for (const s of c)
+          e.append(o, s);
+      else c !== void 0 && e.set(
+        o,
+        typeof c == "object" ? JSON.stringify(c) : c
+      );
+  }
+  return e;
+};
+class I {
+  constructor() {
+    D(this, "fns", []);
+  }
+  clear() {
+    this.fns = [];
+  }
+  eject(e) {
+    const r = this.getInterceptorIndex(e);
+    this.fns[r] && (this.fns[r] = null);
+  }
+  exists(e) {
+    const r = this.getInterceptorIndex(e);
+    return !!this.fns[r];
+  }
+  getInterceptorIndex(e) {
+    return typeof e == "number" ? this.fns[e] ? e : -1 : this.fns.indexOf(e);
+  }
+  update(e, r) {
+    const n = this.getInterceptorIndex(e);
+    return this.fns[n] ? (this.fns[n] = r, e) : !1;
+  }
+  use(e) {
+    return this.fns.push(e), this.fns.length - 1;
+  }
+}
+const ye = () => ({
+  error: new I(),
+  request: new I(),
+  response: new I()
+}), pe = L({
+  allowReserved: !1,
+  array: {
+    explode: !0,
+    style: "form"
+  },
+  object: {
+    explode: !0,
+    style: "deepObject"
+  }
+}), be = {
+  "Content-Type": "application/json"
+}, me = (t = {}) => ({
+  ...te,
+  headers: be,
+  parseAs: "auto",
+  querySerializer: pe,
+  ...t
+}), Ee = (t = {}) => {
+  let e = V(me(), t);
+  const r = () => ({ ...e }), n = (u) => (e = V(e, u), r()), o = ye(), c = async (u) => {
+    const l = {
+      ...e,
+      ...u,
+      fetch: u.fetch ?? e.fetch ?? globalThis.fetch,
+      headers: F(e.headers, u.headers),
+      serializedBody: void 0
+    };
+    l.security && await fe(l), l.requestValidator && await l.requestValidator(l), l.body !== void 0 && l.bodySerializer && (l.serializedBody = l.bodySerializer(l.body)), (l.body === void 0 || l.serializedBody === "") && l.headers.delete("Content-Type");
+    const g = l, m = W(g);
+    return { opts: g, url: m };
+  }, s = async (u) => {
+    const l = u.throwOnError ?? e.throwOnError, g = u.responseStyle ?? e.responseStyle;
+    let m, f;
+    try {
+      const { opts: d, url: h } = await c(u), w = {
+        redirect: "follow",
+        ...d,
+        body: H(d)
+      };
+      m = new Request(h, w);
+      for (const y of o.request.fns)
+        y && (m = await y(m, d));
+      const O = d.fetch;
+      f = await O(m);
+      for (const y of o.response.fns)
+        y && (f = await y(f, m, d));
+      const x = {
+        request: m,
+        response: f
+      };
+      if (f.ok) {
+        const y = (d.parseAs === "auto" ? ue(f.headers.get("Content-Type")) : d.parseAs) ?? "json";
+        if (f.status === 204 || f.headers.get("Content-Length") === "0") {
+          let b;
+          switch (y) {
+            case "arrayBuffer":
+            case "blob":
+            case "text":
+              b = await f[y]();
+              break;
+            case "formData":
+              b = new FormData();
+              break;
+            case "stream":
+              b = f.body;
+              break;
+            case "json":
+            default:
+              b = {};
+              break;
+          }
+          return d.responseStyle === "data" ? b : {
+            data: b,
+            ...x
+          };
+        }
+        let S;
+        switch (y) {
+          case "arrayBuffer":
+          case "blob":
+          case "formData":
+          case "text":
+            S = await f[y]();
+            break;
+          case "json": {
+            const b = await f.text();
+            S = b ? JSON.parse(b) : {};
+            break;
+          }
+          case "stream":
+            return d.responseStyle === "data" ? f.body : {
+              data: f.body,
+              ...x
+            };
+        }
+        return y === "json" && (d.responseValidator && await d.responseValidator(S), d.responseTransformer && (S = await d.responseTransformer(S))), d.responseStyle === "data" ? S : {
+          data: S,
+          ...x
+        };
+      }
+      const q = await f.text();
+      let T;
+      try {
+        T = JSON.parse(q);
+      } catch {
+      }
+      throw T ?? q;
+    } catch (d) {
+      let h = d;
+      for (const w of o.error.fns)
+        w && (h = await w(
+          h,
+          f,
+          m,
+          u
+        ));
+      if (h = h || {}, l)
+        throw h;
+      return g === "data" ? void 0 : {
+        error: h,
+        request: m,
+        response: f
+      };
+    }
+  }, a = (u) => (l) => s({ ...l, method: u }), i = (u) => async (l) => {
+    const { opts: g, url: m } = await c(l);
+    return re({
+      ...g,
+      body: g.body,
+      method: u,
+      onRequest: async (f, d) => {
+        let h = new Request(f, d);
+        for (const w of o.request.fns)
+          w && (h = await w(h, g));
+        return h;
+      },
+      serializedBody: H(g),
+      url: m
+    });
+  };
+  return {
+    buildUrl: (u) => W({ ...e, ...u }),
+    connect: a("CONNECT"),
+    delete: a("DELETE"),
+    get: a("GET"),
+    getConfig: r,
+    head: a("HEAD"),
+    interceptors: o,
+    options: a("OPTIONS"),
+    patch: a("PATCH"),
+    post: a("POST"),
+    put: a("PUT"),
+    request: s,
+    setConfig: n,
+    sse: {
+      connect: i("CONNECT"),
+      delete: i("DELETE"),
+      get: i("GET"),
+      head: i("HEAD"),
+      options: i("OPTIONS"),
+      patch: i("PATCH"),
+      post: i("POST"),
+      put: i("PUT"),
+      trace: i("TRACE")
+    },
+    trace: a("TRACE")
+  };
+};
+export {
+  Se as a,
+  Ee as c
+};