@aerogel/plugin-solid 0.0.1-next.0d1cf82f9dfbe1d3e7ec5644f85f97a43c8c2334

package/dist/aerogel-plugin-solid.js

@@ -0,0 +1,683 @@
+var ne = Object.defineProperty;
+var re = (n, e, i) => e in n ? ne(n, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : n[e] = i;
+var u = (n, e, i) => re(n, typeof e != "symbol" ? e + "" : e, i);
+import { persistent as se, defineServiceState as oe, Events as g, UI as T, translateWithDefault as c, App as m, Colors as ae, Storage as le, Errors as B, defineFormValidationRule as ue, requiredStringProp as ce, computedAsync as de, Cache as R, useForm as he, requiredStringInput as ge, AGMarkdown as A, AGButton as P, AGForm as fe, AGInput as me, AGLink as pe, registerErrorHandler as we, bootServices as Se } from "@aerogel/core";
+import { SolidEngine as ye, SolidTypeIndex as y, SolidContainer as k, SolidACLAuthorization as ve, SolidDocument as be, bootSolidModels as Ie } from "soukai-solid";
+import { JSError as O, arr as Ae, fail as C, PromisedValue as Pe, Storage as x, after as G, required as V, facade as Le, tap as F, arrayUnique as j, objectWithout as z, isDevelopment as J, asyncMemo as H, hasLocationQueryParameter as L, getLocationQueryParameter as q, arrayFilter as $e, setAsyncMemo as Y, urlRoot as Ee, requireUrlParse as Ce, objectWithoutEmpty as Ue, parseBoolean as Q, arrayWithout as Te } from "@noeldemartin/utils";
+import { fetchLoginUserProfile as Re } from "@noeldemartin/solid-utils";
+import { setEngine as ke } from "soukai";
+import { defineComponent as M, createElementBlock as S, openBlock as d, unref as a, computed as K, renderSlot as $, createCommentVNode as _, createVNode as h, createElementVNode as b, withCtx as p, createTextVNode as v, toDisplayString as w, createBlock as I } from "vue";
+class xe extends O {
+}
+function Fe(n, e) {
+  return n;
+}
+class U extends O {
+  constructor(i, t, r) {
+    super(Fe(i), r);
+    u(this, "description");
+    this.description = t;
+  }
+}
+class qe extends O {
+  constructor(e, i) {
+    super(`Container at ${e.url} is already in use`, i);
+  }
+}
+const E = {};
+class X {
+  constructor() {
+    u(this, "name");
+    u(this, "authenticatedFetch");
+    u(this, "booted");
+    u(this, "listeners", Ae([]));
+    u(this, "_engine");
+  }
+  get engine() {
+    return this._engine = this._engine ?? new ye(this.requireAuthenticatedFetch()), this._engine;
+  }
+  getAuthenticatedFetch() {
+    return this.authenticatedFetch ?? null;
+  }
+  requireAuthenticatedFetch() {
+    return this.authenticatedFetch ?? C("Authenticated fetch is not ready");
+  }
+  addListener(e) {
+    return this.listeners.includes(e) || this.listeners.push(e), () => {
+      this.removeListener(e);
+    };
+  }
+  removeListener(e) {
+    this.listeners.includes(e) && this.listeners.remove(e);
+  }
+  async boot() {
+    if (this.booted)
+      return this.booted;
+    this.booted = new Pe(), await this.restoreSession(), this.booted.resolve();
+  }
+  async initAuthenticatedFetch(e) {
+    this.authenticatedFetch = e, await this.notifyListeners("onAuthenticatedFetchReady", e);
+  }
+  async startSession(e) {
+    const i = {
+      authenticator: this,
+      ...e
+    };
+    return await this.notifyListeners("onSessionStarted", i), i;
+  }
+  async failSession(e, i) {
+    await this.notifyListeners("onSessionFailed", e, i);
+  }
+  async endSession() {
+    await this.notifyListeners("onSessionEnded");
+  }
+  async notifyListeners(e, ...i) {
+    await Promise.all(
+      this.listeners.toArray().map(async (t) => {
+        const r = t[e];
+        await (r == null ? void 0 : r(...i));
+      })
+    );
+  }
+}
+const D = "inrupt-authenticator";
+class _e extends X {
+  constructor() {
+    super(...arguments);
+    u(this, "_events");
+    u(this, "_fetch");
+    u(this, "_login");
+    u(this, "_logout");
+    u(this, "_handleIncomingRedirect");
+  }
+  async login(i) {
+    x.set(D, i);
+    const t = {
+      oidcIssuer: i
+    };
+    return E.clientID && (t.clientId = E.clientID.client_id, t.clientName = E.clientID.client_name, t.redirectUrl = E.clientID.redirect_uris[0]), await this._login(t), await G({ seconds: 60 }), C("Browser should have redirected, but it didn't");
+  }
+  async logout() {
+    await this._logout(), await this.endSession();
+  }
+  async restoreSession() {
+    const { events: i, fetch: t, handleIncomingRedirect: r, login: s, logout: l } = await import("./InruptAuthenticator.lazy-BvpQLGoj.js");
+    this._fetch = t, this._login = s, this._logout = l, this._events = i, this._handleIncomingRedirect = r, await this.loginFromRedirect();
+  }
+  async loginFromRedirect() {
+    const i = x.get(D);
+    if (!i)
+      return;
+    this._events().on("error", (r, s) => {
+      r ?? (r = "Error using Inrupt Authenticator method"), typeof s == "object" ? this.failSession(i, new U(r, null, { cause: s })) : this.failSession(i, new U(r, s));
+    });
+    const t = await this._handleIncomingRedirect(globalThis.location.href);
+    x.remove(D), t != null && t.isLoggedIn && t.webId && await this.initSession(t.webId);
+  }
+  async initSession(i) {
+    await this.initAuthenticatedFetch(this._fetch);
+    try {
+      const t = await f.requireUserProfile(i);
+      await this.startSession({ user: t, loginUrl: i });
+    } catch (t) {
+      await this.failSession(i, t);
+    }
+  }
+}
+class De extends X {
+  constructor() {
+    super();
+    u(this, "store");
+    this.store = se("legacy-authenticator", {});
+  }
+  async login(i, t) {
+    const { SolidAuthClient: r } = await import("./LegacyAuthenticator.lazy-ChFFqP14.js");
+    throw this.store.webId = t == null ? void 0 : t.webId, this.store.loginUrl = (t == null ? void 0 : t.oidcIssuerUrl) ?? i, await r.login(this.store.loginUrl) === null ? (delete this.store.webId, delete this.store.loginUrl, new U("Could not log in with Solid using the legacy authenticator")) : (await G({ seconds: 60 }), new Error("Browser should have redirected, but it didn't"));
+  }
+  async logout() {
+    const { SolidAuthClient: i } = await import("./LegacyAuthenticator.lazy-ChFFqP14.js");
+    delete this.store.webId, delete this.store.loginUrl, await i.logout(), await this.endSession();
+  }
+  async restoreSession() {
+    if (!this.store.loginUrl)
+      return;
+    const { SolidAuthClient: i } = await import("./LegacyAuthenticator.lazy-ChFFqP14.js"), t = await i.currentSession(), r = V(this.store.loginUrl);
+    await this.initAuthenticatedFetch((s, l) => i.fetch(s, l));
+    try {
+      const s = await f.requireUserProfile(V((t == null ? void 0 : t.webId) ?? this.store.webId));
+      await this.startSession({ user: s, loginUrl: r });
+    } catch (s) {
+      await this.failSession(r, s);
+    }
+  }
+}
+const W = {}, Oe = {
+  inrupt: new _e(),
+  legacy: new De()
+};
+function Ge(n) {
+  W.default = n;
+}
+function Z(n) {
+  return W[n];
+}
+function Me(n) {
+  Object.entries(n).forEach(([e, i]) => We(e, i));
+}
+function We(n, e) {
+  W[n] = e, e.name = e.name ?? n;
+}
+const N = { autoReconnect: !0 }, Ne = oe({
+  name: "solid",
+  persist: ["autoReconnect", "dismissed", "previousSession", "profiles", "staleProfiles"],
+  initialState: {
+    autoReconnect: N.autoReconnect,
+    dismissed: !1,
+    ignorePreviousSessionError: !1,
+    loginStartupError: null,
+    loginOngoing: !1,
+    preferredAuthenticator: null,
+    previousSession: null,
+    profiles: {},
+    session: null,
+    loginStale: !1,
+    staleProfiles: []
+  },
+  serialize(n) {
+    var e;
+    return ((e = n.previousSession) == null ? void 0 : e.error) instanceof Error && (n.previousSession.error = n.previousSession.error.message), n;
+  },
+  computed: {
+    user: (n) => {
+      var e, i;
+      return ((e = n.session) == null ? void 0 : e.user) ?? ((i = n.previousSession) == null ? void 0 : i.profile) ?? null;
+    },
+    authenticator: (n) => {
+      var e;
+      return ((e = n.session) == null ? void 0 : e.authenticator) ?? null;
+    },
+    fetch() {
+      var n;
+      return ((n = this.authenticator) == null ? void 0 : n.getAuthenticatedFetch()) ?? globalThis.fetch.bind(globalThis);
+    },
+    error(n) {
+      var e;
+      return n.loginStartupError ? n.loginStartupError ?? null : n.ignorePreviousSessionError ? null : ((e = n.previousSession) == null ? void 0 : e.error) ?? null;
+    }
+  }
+});
+class Be extends Ne {
+  isLoggedIn() {
+    return !!this.session;
+  }
+  wasLoggedIn() {
+    return !!this.previousSession;
+  }
+  hasLoggedIn() {
+    return !!(this.session || this.previousSession);
+  }
+  requireAuthenticator() {
+    return this.authenticator ?? C("Could not get authenticator");
+  }
+  requireUser() {
+    return this.user ?? C("Could not get user profile (are you logged in?)");
+  }
+  requireUserProfile(e) {
+    return this.getUserProfile(e, { required: !0 });
+  }
+  /* eslint-enable max-len */
+  async getUserProfile(e, i = {}) {
+    var l;
+    let t = null;
+    const r = i.markStale ?? !((l = this.authenticator) != null && l.getAuthenticatedFetch()), s = this.profiles[e] ?? await F(
+      await Re(e, {
+        fetch: this.fetch,
+        required: i.required ?? !1,
+        onLoaded(o) {
+          t = o;
+        }
+      }),
+      async (o) => {
+        o && (t && await g.emit("solid:user-profile-loaded", [o, t]), this.rememberProfile(o));
+      }
+    );
+    return s && r && this.setState({ staleProfiles: j(this.staleProfiles.concat([s.webId])) }), s;
+  }
+  async refreshUserProfile() {
+    if (!this.isLoggedIn())
+      return;
+    this.setState({ profiles: z(this.profiles, [this.user.webId]) });
+    const e = await this.requireUserProfile(this.user.webId);
+    this.setState({
+      session: {
+        ...this.session,
+        user: e
+      }
+    });
+  }
+  async login(e, i = {}) {
+    if (J() && e === "dev" && (e = "http://localhost:3000"), /^https?:\/\//.test(e) || (i.fallbackUrl ?? (i.fallbackUrl = `http://${e}`), e = `https://${e}`), this.isLoggedIn())
+      return !0;
+    if (this.loginOngoing)
+      throw new Error("Authentication already in progress");
+    return i.loading ? T.loading(c("solid.loggingIn", "Logging in..."), () => this.attemptLogin(e, i)) : this.attemptLogin(e, i);
+  }
+  async reconnect(e = {}) {
+    const { force: i, ...t } = e;
+    this.isLoggedIn() || !this.previousSession || this.previousSession.error !== null && !i || await this.login(this.previousSession.loginUrl, {
+      authenticator: this.previousSession.authenticator,
+      ...t,
+      loading: t.loading ?? !1
+    });
+  }
+  async logout(e = !1) {
+    var l, o;
+    const i = !m.plugin("@aerogel/local-first") || !!((l = m.service("$cloud")) != null && l.ready), t = !m.plugin("@aerogel/local-first") || !!((o = m.service("$cloud")) != null && o.dirty), [r, s] = e ? [!0, { wipeLocalData: i }] : await T.confirm(
+      i ? c("solid.logoutConfirmTitle", "Log out from this device?") : c("solid.disconnectConfirmTitle", "Disconnect account?"),
+      i ? t ? c(
+        "solid.logoutConfirmMessageWithLocalChanges",
+        "There are some changes that haven't been synchronized and will be lost, but the rest of the data will remain in your Solid POD."
+      ) : c(
+        "solid.logoutConfirmMessage",
+        "Logging out will remove all the data from this device, but you'll still have it in your Solid POD."
+      ) : c(
+        "solid.disconnectConfirmMessage",
+        "You'll need to introduce your credentials again to connect to your Solid POD."
+      ),
+      {
+        acceptText: c("solid.logoutConfirmAccept", "Log out"),
+        acceptColor: ae.Danger,
+        cancelText: c(
+          "solid.logoutConfirmCancel",
+          c("ui.cancel", "Cancel")
+        ),
+        checkboxes: i ? t ? {
+          wipeLocalData: {
+            label: c(
+              "solid.logoutConfirmWipeNotice",
+              "I understand that changes that haven't been synchronized will be lost."
+            ),
+            default: !1,
+            required: !0
+          }
+        } : void 0 : {
+          wipeLocalData: {
+            label: c(
+              "solid.logoutConfirmWipe",
+              "Also remove all existing data (tasks, lists, etc.)"
+            ),
+            default: !1
+          }
+        }
+      }
+    );
+    r && this.previousSession && await T.loading(c("solid.logoutOngoing", "Logging out..."), async () => {
+      this.setState({
+        dismissed: !1,
+        ignorePreviousSessionError: !1,
+        loginStartupError: null,
+        previousSession: null,
+        ...N
+      }), this.isLoggedIn() && await this.authenticator.logout(), (s.wipeLocalData ?? !0) && await le.purge(), await g.emit("auth:logout"), await g.emit("auth:after-logout");
+    });
+  }
+  async whenLoggedIn(e) {
+    return this.isLoggedIn() ? e(this.session) : new Promise((i) => {
+      const t = (r) => i(e(r));
+      g.once("auth:login", t);
+    });
+  }
+  dismiss() {
+    this.setState({ dismissed: !0 });
+  }
+  async findOrCreatePrivateTypeIndex() {
+    return await this.findPrivateTypeIndex() ?? await this.createPrivateTypeIndex();
+  }
+  async findPrivateTypeIndex() {
+    const { webId: e, privateTypeIndexUrl: i } = this.requireUser(), t = this.requireAuthenticator().engine;
+    return i ? H(`${e}-privateTypeIndex`, () => y.withEngine(t).find(i)) : null;
+  }
+  async findOrCreatePublicTypeIndex() {
+    return await this.findPublicTypeIndex() ?? await this.createPublicTypeIndex();
+  }
+  async findPublicTypeIndex() {
+    const { webId: e, publicTypeIndexUrl: i } = this.requireUser(), t = this.requireAuthenticator().engine;
+    return i ? H(`${e}-publicTypeIndex`, () => y.withEngine(t).find(i)) : null;
+  }
+  async createPrivateContainer(e) {
+    const i = this.requireAuthenticator().engine;
+    return k.withEngine(i, async () => {
+      const t = await k.find(e.url);
+      if (t && !e.reuseExisting)
+        throw new qe(t);
+      const r = t ?? new k({ url: e.url, name: e.name });
+      if (await r.save(), e.registerFor) {
+        const s = await this.findOrCreatePrivateTypeIndex();
+        await r.register(s, e.registerFor);
+      }
+      return r;
+    });
+  }
+  async boot() {
+    var e, i;
+    await B.booted, L("authenticator") && this.setState({
+      preferredAuthenticator: q("authenticator")
+    }), L("refreshProfile") && this.setState({
+      staleProfiles: j(
+        this.staleProfiles.concat($e([(e = this.session) == null ? void 0 : e.user.webId, (i = this.previousSession) == null ? void 0 : i.loginUrl]))
+      )
+    }), await this.restorePreviousSession(), await this.startupReconnect();
+  }
+  async createPrivateTypeIndex() {
+    const e = this.requireUser(), i = this.requireAuthenticator(), t = await y.withEngine(i.engine).createPrivate(e);
+    return F(t, () => {
+      e.privateTypeIndexUrl = t.url, Y(`${e.webId}-privateTypeIndex`, t), this.rememberProfile(e);
+    });
+  }
+  async createPublicTypeIndex() {
+    const e = this.requireUser(), i = this.requireAuthenticator(), t = await y.withEngine(i.engine).createPublic(e);
+    return F(t, () => {
+      e.privateTypeIndexUrl = t.url, Y(`${e.webId}-publicTypeIndex`, t), this.rememberProfile(e);
+    });
+  }
+  async attemptLogin(e, i) {
+    const t = i.authenticator ?? this.preferredAuthenticator ?? "default", r = i.onError ?? ((o) => m.isMounted() ? B.report(o) : this.setState({ loginStartupError: o })), s = setTimeout(() => this.loginStale = !0, 1e4), l = {
+      dismissed: this.dismissed,
+      ignorePreviousSessionError: this.ignorePreviousSessionError,
+      previousSession: this.previousSession
+    };
+    this.loginOngoing = !0;
+    try {
+      const o = await this.getUserProfile(e, { markStale: !0 }), ee = (o == null ? void 0 : o.oidcIssuerUrl) ?? Ee((o == null ? void 0 : o.webId) ?? e), te = await this.bootAuthenticator(t), { domain: ie } = Ce(e);
+      return this.setState({
+        dismissed: !1,
+        ignorePreviousSessionError: !0,
+        previousSession: Ue({
+          profile: o,
+          loginUrl: e,
+          authenticator: t,
+          error: c(
+            "auth.stuckConnecting",
+            `We didn't hear back from the identity provider at \`${ie}\`, maybe try reconnecting?`
+          )
+        })
+      }), await g.emit("auth:before-login"), await te.login(ee, o), !0;
+    } catch (o) {
+      return this.setState(l), o instanceof xe ? !1 : i.fallbackUrl ? G().then(() => this.login(i.fallbackUrl ?? "", z(i, "fallbackUrl"))) : (r(o), !1);
+    } finally {
+      clearTimeout(s), this.setState({
+        loginOngoing: !1,
+        loginStale: !1
+      });
+    }
+  }
+  async restorePreviousSession() {
+    this.previousSession && await this.bootAuthenticator(this.previousSession.authenticator);
+  }
+  async startupReconnect() {
+    this.reconnectOnStartup() && await this.reconnect({ force: this.forcingReconnect() });
+  }
+  reconnectOnStartup() {
+    return L("autoReconnect") ? Q(q("autoReconnect")) : this.autoReconnect;
+  }
+  forcingReconnect() {
+    return L("autoReconnect") && Q(q("autoReconnect"));
+  }
+  async bootAuthenticator(e) {
+    const i = Z(e);
+    return i.addListener({
+      onSessionStarted: async (t) => {
+        this.setState({
+          session: t,
+          previousSession: {
+            authenticator: i.name,
+            loginUrl: t.loginUrl,
+            profile: t.user,
+            error: null
+          }
+        }), this.staleProfiles.includes(t.user.webId) && await this.refreshUserProfile(), m.plugin("@aerogel/local-first") || ke(t.authenticator.engine), ve.setEngine(t.authenticator.engine), y.setEngine(t.authenticator.engine), be.setEngine(t.authenticator.engine), await g.emit("auth:login", t);
+      },
+      onSessionFailed: async (t, r) => {
+        var s;
+        this.setState({
+          session: null,
+          previousSession: {
+            profile: (s = this.previousSession) == null ? void 0 : s.profile,
+            authenticator: i.name,
+            loginUrl: t,
+            error: r
+          }
+        });
+      },
+      onSessionEnded: () => this.setState({ session: null }),
+      onAuthenticatedFetchReady: (t) => g.emit("auth:fetch-ready", t)
+    }), await i.boot(), i;
+  }
+  rememberProfile(e) {
+    this.setState({
+      profiles: {
+        ...this.profiles,
+        [e.webId]: e
+      },
+      staleProfiles: Te(this.staleProfiles, e.webId)
+    });
+  }
+}
+const f = Le(Be);
+function Ve() {
+  ue("container_url", (n) => {
+    if (!n.endsWith("/"))
+      return "containerEndingSlashMissing";
+  });
+}
+const je = ["src"], ze = /* @__PURE__ */ M({
+  __name: "AGSolidImage",
+  props: { src: ce() },
+  setup(n) {
+    const e = n, i = de(async () => {
+      const r = await R.get(e.src) ?? await t(e.src), s = await (r == null ? void 0 : r.blob());
+      return s && URL.createObjectURL(s);
+    });
+    async function t(r) {
+      try {
+        const s = await f.fetch(r);
+        return s.status !== 200 ? null : (await R.store(r, s), R.get(r));
+      } catch {
+        return null;
+      }
+    }
+    return (r, s) => (d(), S("img", { src: a(i) }, null, 8, je));
+  }
+}), He = { class: "flex flex-col gap-3" }, Ye = { class: "flex flex-col" }, Qe = {
+  key: 1,
+  class: "mt-1 self-center text-sm text-red-800"
+}, ut = /* @__PURE__ */ M({
+  __name: "AGSolidStatus",
+  setup(n) {
+    const e = he({ url: ge() }), i = K(
+      () => J() && (!e.url || e.url === "dev" || e.url.trim().length === 0)
+    );
+    return (t, r) => (d(), S("div", null, [
+      t.$solid.loginStale ? $(t.$slots, "login-stale", { key: 0 }, () => [
+        h(a(A), {
+          text: t.$td("solid.loginStale", "This is taking too long...")
+        }, null, 8, ["text"])
+      ]) : _("", !0),
+      t.$solid.loginOngoing ? $(t.$slots, "login-ongoing", { key: 1 }, () => [
+        h(a(A), {
+          text: t.$td("ui.loading", "Loading...")
+        }, null, 8, ["text"])
+      ]) : t.$solid.isLoggedIn() ? $(t.$slots, "logged-in", {
+        key: 2,
+        session: t.$solid.session
+      }, () => [
+        b("div", He, [
+          h(a(A), {
+            text: t.$td("solid.loggedIn", "You are logged in as [{userName}]({userWebId})", {
+              userName: t.$solid.user.name ?? t.$solid.user.webId,
+              userWebId: t.$solid.user.webId
+            })
+          }, null, 8, ["text"]),
+          h(a(P), {
+            onClick: r[0] || (r[0] = (s) => t.$solid.logout())
+          }, {
+            default: p(() => [
+              v(w(t.$td("solid.logout", "Logout")), 1)
+            ]),
+            _: 1
+          })
+        ])
+      ]) : $(t.$slots, "logged-out", { key: 3 }, () => {
+        var s;
+        return [
+          b("div", Ye, [
+            h(a(fe), {
+              form: a(e),
+              class: "flex",
+              onSubmit: r[2] || (r[2] = (l) => t.$solid.login(a(e).url))
+            }, {
+              default: p(() => [
+                h(a(me), {
+                  name: "url",
+                  "aria-label": t.$td("solid.url", "Login url"),
+                  placeholder: t.$td("solid.placeholder", "https://...")
+                }, null, 8, ["aria-label", "placeholder"]),
+                i.value ? (d(), I(a(P), {
+                  key: 0,
+                  submit: "",
+                  onClick: r[1] || (r[1] = (l) => a(e).url = "dev")
+                }, {
+                  default: p(() => [
+                    v(w(t.$td("solid.devLogin", "Dev login")), 1)
+                  ]),
+                  _: 1
+                })) : (d(), I(a(P), {
+                  key: 1,
+                  submit: ""
+                }, {
+                  default: p(() => [
+                    v(w(t.$td("solid.login", "Login")), 1)
+                  ]),
+                  _: 1
+                }))
+              ]),
+              _: 1
+            }, 8, ["form"]),
+            t.$solid.wasLoggedIn() ? (d(), I(a(P), {
+              key: 0,
+              class: "mt-3",
+              onClick: r[3] || (r[3] = (l) => t.$solid.reconnect({ force: !0 }))
+            }, {
+              default: p(() => [
+                v(w(t.$td("solid.reconnect", "Reconnect")), 1)
+              ]),
+              _: 1
+            })) : _("", !0),
+            (s = t.$solid.previousSession) != null && s.error || t.$solid.loginStartupError ? (d(), S("p", Qe, [
+              h(a(A), {
+                text: t.$td("solid.previousLoginError", "Previous login attempt failed"),
+                inline: ""
+              }, null, 8, ["text"]),
+              h(a(pe), {
+                onClick: r[4] || (r[4] = (l) => {
+                  var o;
+                  return t.$errors.inspect(((o = t.$solid.previousSession) == null ? void 0 : o.error) || t.$solid.loginStartupError);
+                })
+              }, {
+                default: p(() => [
+                  v(" (" + w(t.$td("errors.viewDetails", "View details")) + ") ", 1)
+                ]),
+                _: 1
+              })
+            ])) : _("", !0)
+          ])
+        ];
+      })
+    ]));
+  }
+}), Je = {
+  viewBox: "0 0 20 20",
+  width: "1.2em",
+  height: "1.2em"
+};
+function Ke(n, e) {
+  return d(), S("svg", Je, e[0] || (e[0] = [
+    b("path", {
+      fill: "currentColor",
+      d: "M15 2H5L4 8h12zM0 10s2 1 10 1s10-1 10-1l-4-2H4zm8 4h4v1H8z"
+    }, null, -1),
+    b("circle", {
+      cx: "6",
+      cy: "15",
+      r: "3",
+      fill: "currentColor"
+    }, null, -1),
+    b("circle", {
+      cx: "14",
+      cy: "15",
+      r: "3",
+      fill: "currentColor"
+    }, null, -1)
+  ]));
+}
+const Xe = { name: "ooui-user-anonymous", render: Ke }, Ze = { class: "relative flex items-center justify-center rounded-full bg-gray-200" }, et = {
+  key: 1,
+  class: "text-sm font-semibold tracking-wider text-gray-500",
+  "aria-hidden": "true"
+}, ct = /* @__PURE__ */ M({
+  __name: "AGSolidUserAvatar",
+  setup(n) {
+    const e = K(() => {
+      var t;
+      return (((t = f.user) == null ? void 0 : t.name) ?? "").trim().split(" ").map((r) => {
+        var s;
+        return (s = r[0]) == null ? void 0 : s.toUpperCase();
+      }).join("").slice(0, 3);
+    });
+    return (i, t) => {
+      var r, s;
+      return d(), S("div", Ze, [
+        (r = i.$solid.user) != null && r.avatarUrl ? (d(), I(ze, {
+          key: 0,
+          src: (s = i.$solid.user) == null ? void 0 : s.avatarUrl,
+          alt: "",
+          class: "absolute inset-0 h-full w-full rounded-full"
+        }, null, 8, ["src"])) : e.value ? (d(), S("span", et, w(e.value), 1)) : (d(), I(a(Xe), {
+          key: 2,
+          class: "h-6 w-6 text-gray-500"
+        }))
+      ]);
+    };
+  }
+}), tt = { $solid: f };
+function dt(n = {}) {
+  return {
+    async install(e) {
+      Ie(), Me({ ...Oe, ...n.authenticators ?? {} }), Ve(), Ge(Z(n.defaultAuthenticator ?? "inrupt")), we((i) => {
+        if (i instanceof U)
+          return i.description ? `${i.message} (${i.description})` : i.message;
+      }), typeof n.autoReconnect == "boolean" && (N.autoReconnect = n.autoReconnect, f.hasPersistedState() || (f.autoReconnect = n.autoReconnect)), n.onUserProfileLoaded && g.on("solid:user-profile-loaded", ([i, t]) => {
+        var r;
+        (r = n.onUserProfileLoaded) == null || r.call(n, i, t);
+      }), await Se(e, tt);
+    }
+  };
+}
+export {
+  ze as AGSolidImage,
+  ut as AGSolidStatus,
+  ct as AGSolidUserAvatar,
+  xe as AuthenticationCancelledError,
+  U as AuthenticationFailedError,
+  X as Authenticator,
+  qe as ContainerAlreadyInUse,
+  f as Solid,
+  Be as SolidService,
+  Oe as authenticators,
+  dt as default,
+  Z as getAuthenticator,
+  We as registerAuthenticator,
+  Me as registerAuthenticators,
+  Ge as setDefaultAuthenticator
+};
+//# sourceMappingURL=aerogel-plugin-solid.js.map