@aerogel/plugin-solid 0.0.1 → 0.1.0

package/dist/aerogel-plugin-solid.js

@@ -0,0 +1,724 @@
+var ce = Object.defineProperty;
+var de = (n, e, t) => e in n ? ce(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var h = (n, e, t) => de(n, typeof e != "symbol" ? e + "" : e, t);
+import { persistent as he, defineServiceState as ge, Events as f, UI as x, translateWithDefault as u, App as m, Storage as fe, Errors as G, defineFormValidationRule as me, computedAsync as we, Cache as F, useForm as pe, stringInput as ye, requiredStringInput as ve, classes as J, Form as Se, Input as be, Select as Ie, Button as k, Link as Le, registerErrorHandler as Ae, bootServices as Pe } from "@aerogel/core";
+import { SolidEngine as Ce, SolidTypeIndex as S, SolidContainer as q, SolidACLAuthorization as Ee, SolidDocument as xe, bootSolidModels as Ue } from "soukai-solid";
+import { JSError as j, arr as Te, fail as U, PromisedValue as $e, Storage as O, after as H, required as K, facade as _e, tap as D, arrayUnique as X, objectWithout as Z, isDevelopment as Re, resetAsyncMemo as ee, asyncMemo as te, hasLocationQueryParameter as A, getLocationQueryParameter as z, arrayFilter as Fe, setAsyncMemo as ie, urlRoot as ke, requireUrlParse as qe, objectWithoutEmpty as Oe, parseBoolean as ne, arrayWithout as De } from "@noeldemartin/utils";
+import { fetchLoginUserProfile as ze } from "@noeldemartin/solid-utils";
+import { setEngine as Me } from "soukai";
+import P from "virtual:aerogel-solid";
+import { markRaw as se, createElementBlock as p, openBlock as d, createElementVNode as v, defineComponent as W, unref as l, computed as I, createBlock as w, toDisplayString as L, ref as re, resolveDirective as Be, normalizeClass as C, withCtx as b, createCommentVNode as M, createVNode as B, withDirectives as Ve, createTextVNode as E } from "vue";
+class je extends j {
+}
+function He(n, e) {
+  return n;
+}
+class T extends j {
+  constructor(t, i, r) {
+    super(He(t), r);
+    h(this, "description");
+    this.description = i;
+  }
+}
+class We extends j {
+  constructor(e, t) {
+    super(`Container at ${e.url} is already in use`, t);
+  }
+}
+class oe {
+  constructor() {
+    h(this, "name");
+    h(this, "authenticatedFetch");
+    h(this, "booted");
+    h(this, "listeners", Te([]));
+    h(this, "_engine");
+  }
+  get engine() {
+    return this._engine = this._engine ?? new Ce(this.requireAuthenticatedFetch()), this._engine;
+  }
+  getAuthenticatedFetch() {
+    return this.authenticatedFetch ?? null;
+  }
+  requireAuthenticatedFetch() {
+    return this.authenticatedFetch ?? U("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 $e(), await this.restoreSession(), this.booted.resolve();
+  }
+  async initAuthenticatedFetch(e) {
+    this.authenticatedFetch = e, await this.notifyListeners("onAuthenticatedFetchReady", e);
+  }
+  async startSession(e) {
+    const t = {
+      authenticator: this,
+      ...e
+    };
+    return await this.notifyListeners("onSessionStarted", t), t;
+  }
+  async failSession(e, t) {
+    await this.notifyListeners("onSessionFailed", e, t);
+  }
+  async endSession() {
+    await this.notifyListeners("onSessionEnded");
+  }
+  async notifyListeners(e, ...t) {
+    await Promise.all(
+      this.listeners.toArray().map(async (i) => {
+        const r = i[e];
+        await (r == null ? void 0 : r(...t));
+      })
+    );
+  }
+}
+const V = "inrupt-authenticator";
+class Ne extends oe {
+  constructor() {
+    super(...arguments);
+    h(this, "_events");
+    h(this, "_fetch");
+    h(this, "_login");
+    h(this, "_logout");
+    h(this, "_handleIncomingRedirect");
+  }
+  async login(t) {
+    O.set(V, t);
+    const i = {
+      oidcIssuer: t
+    };
+    return P.clientID && (i.clientId = P.clientID.client_id, i.clientName = P.clientID.client_name, i.redirectUrl = P.clientID.redirect_uris[0]), await this._login(i), await H({ seconds: 60 }), U("Browser should have redirected, but it didn't");
+  }
+  async logout() {
+    await this._logout(), await this.endSession();
+  }
+  async restoreSession() {
+    const { events: t, fetch: i, handleIncomingRedirect: r, login: s, logout: c } = await import("./InruptAuthenticator.lazy-BvpQLGoj.js");
+    this._fetch = i, this._login = s, this._logout = c, this._events = t, this._handleIncomingRedirect = r, await this.loginFromRedirect();
+  }
+  async loginFromRedirect() {
+    const t = O.get(V);
+    if (!t)
+      return;
+    this._events().on("error", (r, s) => {
+      r ?? (r = "Error using Inrupt Authenticator method"), typeof s == "object" ? this.failSession(t, new T(r, null, { cause: s })) : this.failSession(t, new T(r, s));
+    });
+    const i = await this._handleIncomingRedirect(globalThis.location.href);
+    O.remove(V), i != null && i.isLoggedIn && i.webId && await this.initSession(i.webId);
+  }
+  async initSession(t) {
+    await this.initAuthenticatedFetch(this._fetch);
+    try {
+      const i = await g.requireUserProfile(t);
+      await this.startSession({ user: i, loginUrl: t });
+    } catch (i) {
+      await this.failSession(t, i);
+    }
+  }
+}
+class Qe extends oe {
+  constructor() {
+    super();
+    h(this, "store");
+    this.store = he("legacy-authenticator", {});
+  }
+  async login(t, i) {
+    const { SolidAuthClient: r } = await import("./LegacyAuthenticator.lazy-ChFFqP14.js");
+    throw this.store.webId = i == null ? void 0 : i.webId, this.store.loginUrl = (i == null ? void 0 : i.oidcIssuerUrl) ?? t, await r.login(this.store.loginUrl) === null ? (delete this.store.webId, delete this.store.loginUrl, new T("Could not log in with Solid using the legacy authenticator")) : (await H({ seconds: 60 }), new Error("Browser should have redirected, but it didn't"));
+  }
+  async logout() {
+    const { SolidAuthClient: t } = await import("./LegacyAuthenticator.lazy-ChFFqP14.js");
+    delete this.store.webId, delete this.store.loginUrl, await t.logout(), await this.endSession();
+  }
+  async restoreSession() {
+    if (!this.store.loginUrl)
+      return;
+    const { SolidAuthClient: t } = await import("./LegacyAuthenticator.lazy-ChFFqP14.js"), i = await t.currentSession(), r = K(this.store.loginUrl);
+    await this.initAuthenticatedFetch((s, c) => t.fetch(s, c));
+    try {
+      const s = await g.requireUserProfile(K((i == null ? void 0 : i.webId) ?? this.store.webId));
+      await this.startSession({ user: s, loginUrl: r });
+    } catch (s) {
+      await this.failSession(r, s);
+    }
+  }
+}
+const N = {}, Ye = {
+  inrupt: new Ne(),
+  legacy: new Qe()
+};
+function Ge(n) {
+  N.default = n;
+}
+function ae(n) {
+  return N[n];
+}
+function Je(n) {
+  Object.entries(n).forEach(([e, t]) => Ke(e, t));
+}
+function Ke(n, e) {
+  N[n] = e, e.name = e.name ?? n;
+}
+const Q = { autoReconnect: !0 }, Xe = ge({
+  name: "solid",
+  persist: ["autoReconnect", "dismissed", "previousSession", "profiles", "staleProfiles"],
+  initialState: {
+    autoReconnect: Q.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, t;
+      return ((e = n.session) == null ? void 0 : e.user) ?? ((t = n.previousSession) == null ? void 0 : t.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 Ze extends Xe {
+  isLoggedIn() {
+    return !!this.session;
+  }
+  wasLoggedIn() {
+    return !!this.previousSession;
+  }
+  hasLoggedIn() {
+    return !!(this.session || this.previousSession);
+  }
+  requireAuthenticator() {
+    return this.authenticator ?? U("Could not get authenticator");
+  }
+  requireUser() {
+    return this.user ?? U("Could not get user profile (are you logged in?)");
+  }
+  requireUserProfile(e) {
+    return this.getUserProfile(e, { required: !0 });
+  }
+  /* eslint-enable max-len */
+  async getUserProfile(e, t = {}) {
+    var c;
+    let i = null;
+    const r = t.markStale ?? !((c = this.authenticator) != null && c.getAuthenticatedFetch()), s = this.profiles[e] ?? await D(
+      await ze(e, {
+        fetch: this.fetch,
+        required: t.required ?? !1,
+        onLoaded(o) {
+          i = o;
+        }
+      }),
+      async (o) => {
+        o && (i && await f.emit("solid:user-profile-loaded", [o, i]), this.rememberProfile(o));
+      }
+    );
+    return s && r && this.setState({ staleProfiles: X(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, t = {}) {
+    if (Re() && e === "dev" && (e = "http://localhost:3000"), /^https?:\/\//.test(e) || (t.fallbackUrl ?? (t.fallbackUrl = `http://${e}`), e = `https://${e}`), this.isLoggedIn())
+      return !0;
+    if (this.loginOngoing)
+      throw new Error("Authentication already in progress");
+    return t.loading ? x.loading(u("solid.loginOngoing", "Logging in..."), () => this.attemptLogin(e, t)) : this.attemptLogin(e, t);
+  }
+  async reconnect(e = {}) {
+    const { force: t, ...i } = e;
+    this.isLoggedIn() || !this.previousSession || this.previousSession.error !== null && !t || await this.login(this.previousSession.loginUrl, {
+      authenticator: this.previousSession.authenticator,
+      ...i,
+      loading: i.loading ?? !1
+    });
+  }
+  async logout(e = !1) {
+    var c, o;
+    const t = !m.plugin("@aerogel/local-first") || !!((c = m.service("$cloud")) != null && c.ready), i = !m.plugin("@aerogel/local-first") || !!((o = m.service("$cloud")) != null && o.dirty), [r, s] = e ? [!0, { wipeLocalData: t }] : await x.confirm(
+      t ? u("solid.logoutConfirmTitle", "Log out from this device?") : u("solid.disconnectConfirmTitle", "Disconnect account?"),
+      t ? i ? u(
+        "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."
+      ) : u(
+        "solid.logoutConfirmMessage",
+        "Logging out will remove all the data from this device, but you'll still have it in your Solid POD."
+      ) : u(
+        "solid.disconnectConfirmMessage",
+        "You'll need to introduce your credentials again to connect to your Solid POD."
+      ),
+      {
+        acceptText: u("solid.logoutConfirmAccept", "Log out"),
+        acceptVariant: "danger",
+        cancelText: u(
+          "solid.logoutConfirmCancel",
+          u("ui.cancel", "Cancel")
+        ),
+        checkboxes: t ? i ? {
+          wipeLocalData: {
+            label: u(
+              "solid.logoutConfirmWipeNotice",
+              "I understand that changes that haven't been synchronized will be lost."
+            ),
+            default: !1,
+            required: !0
+          }
+        } : void 0 : {
+          wipeLocalData: {
+            label: u(
+              "solid.logoutConfirmWipe",
+              "Also remove all existing data"
+            ),
+            default: !1
+          }
+        }
+      }
+    );
+    r && this.previousSession && await x.loading(u("solid.logoutOngoing", "Logging out..."), async () => {
+      this.setState({
+        dismissed: !1,
+        ignorePreviousSessionError: !1,
+        loginStartupError: null,
+        previousSession: null,
+        ...Q
+      }), this.isLoggedIn() && await this.authenticator.logout(), (s.wipeLocalData ?? !0) && await fe.purge(), await f.emit("auth:logout"), await f.emit("auth:after-logout");
+    });
+  }
+  async whenLoggedIn(e) {
+    return this.isLoggedIn() ? e(this.session) : new Promise((t) => {
+      const i = (r) => t(e(r));
+      f.once("auth:login", i);
+    });
+  }
+  dismiss() {
+    this.setState({ dismissed: !0 });
+  }
+  async findOrCreatePrivateTypeIndex() {
+    return await this.findPrivateTypeIndex() ?? await this.createPrivateTypeIndex();
+  }
+  async findPrivateTypeIndex(e = {}) {
+    const { webId: t, privateTypeIndexUrl: i } = this.requireUser(), r = this.requireAuthenticator().engine;
+    return i ? (e.fresh && ee(`${t}-privateTypeIndex`), te(`${t}-privateTypeIndex`, () => S.withEngine(r).find(i))) : null;
+  }
+  async findOrCreatePublicTypeIndex() {
+    return await this.findPublicTypeIndex() ?? await this.createPublicTypeIndex();
+  }
+  async findPublicTypeIndex(e = {}) {
+    const { webId: t, publicTypeIndexUrl: i } = this.requireUser(), r = this.requireAuthenticator().engine;
+    return i ? (e.fresh && ee(`${t}-publicTypeIndex`), te(`${t}-publicTypeIndex`, () => S.withEngine(r).find(i))) : null;
+  }
+  async createPrivateContainer(e) {
+    const t = this.requireAuthenticator().engine;
+    return q.withEngine(t, async () => {
+      const i = await q.find(e.url);
+      if (i && !e.reuseExisting)
+        throw new We(i);
+      const r = i ?? new q({ 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, t;
+    await G.booted, A("authenticator") && this.setState({
+      preferredAuthenticator: z("authenticator")
+    }), A("refreshProfile") && this.setState({
+      staleProfiles: X(
+        this.staleProfiles.concat(Fe([(e = this.session) == null ? void 0 : e.user.webId, (t = this.previousSession) == null ? void 0 : t.loginUrl]))
+      )
+    }), await this.restorePreviousSession(), await this.startupReconnect();
+  }
+  async createPrivateTypeIndex() {
+    const e = this.requireUser(), t = this.requireAuthenticator(), i = await S.withEngine(t.engine).createPrivate(e);
+    return D(i, () => {
+      e.privateTypeIndexUrl = i.url, ie(`${e.webId}-privateTypeIndex`, i), this.rememberProfile(e);
+    });
+  }
+  async createPublicTypeIndex() {
+    const e = this.requireUser(), t = this.requireAuthenticator(), i = await S.withEngine(t.engine).createPublic(e);
+    return D(i, () => {
+      e.privateTypeIndexUrl = i.url, ie(`${e.webId}-publicTypeIndex`, i), this.rememberProfile(e);
+    });
+  }
+  async attemptLogin(e, t) {
+    const i = t.authenticator ?? this.preferredAuthenticator ?? "default", r = t.onError ?? ((o) => m.isMounted() ? G.report(o) : this.setState({ loginStartupError: o })), s = setTimeout(() => this.loginStale = !0, 1e4), c = {
+      dismissed: this.dismissed,
+      ignorePreviousSessionError: this.ignorePreviousSessionError,
+      previousSession: this.previousSession
+    };
+    this.loginOngoing = !0;
+    try {
+      const o = await this.getUserProfile(e, { markStale: !0 }), $ = (o == null ? void 0 : o.oidcIssuerUrl) ?? ke((o == null ? void 0 : o.webId) ?? e), _ = await this.bootAuthenticator(i), { domain: R } = qe(e);
+      return this.setState({
+        dismissed: !1,
+        ignorePreviousSessionError: !0,
+        previousSession: Oe({
+          profile: o,
+          loginUrl: e,
+          authenticator: i,
+          error: u(
+            "solid.stuckConnecting",
+            "We didn't hear back from the identity provider at `{domain}`, maybe try reconnecting?",
+            { domain: R }
+          )
+        })
+      }), await f.emit("auth:before-login"), await _.login($, o), !0;
+    } catch (o) {
+      return this.setState(c), o instanceof je ? !1 : t.fallbackUrl ? H().then(() => this.login(t.fallbackUrl ?? "", Z(t, "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 A("autoReconnect") ? ne(z("autoReconnect")) : this.autoReconnect;
+  }
+  forcingReconnect() {
+    return A("autoReconnect") && ne(z("autoReconnect"));
+  }
+  async bootAuthenticator(e) {
+    const t = ae(e);
+    return t.addListener({
+      onSessionStarted: async (i) => {
+        this.setState({
+          session: i,
+          previousSession: {
+            authenticator: t.name,
+            loginUrl: i.loginUrl,
+            profile: i.user,
+            error: null
+          }
+        }), this.staleProfiles.includes(i.user.webId) && await this.refreshUserProfile(), m.plugin("@aerogel/local-first") || Me(i.authenticator.engine), Ee.setEngine(i.authenticator.engine), S.setEngine(i.authenticator.engine), xe.setEngine(i.authenticator.engine), await f.emit("auth:login", i);
+      },
+      onSessionFailed: async (i, r) => {
+        var s;
+        this.setState({
+          session: null,
+          previousSession: {
+            profile: (s = this.previousSession) == null ? void 0 : s.profile,
+            authenticator: t.name,
+            loginUrl: i,
+            error: r
+          }
+        });
+      },
+      onSessionEnded: () => this.setState({ session: null }),
+      onAuthenticatedFetchReady: (i) => f.emit("auth:fetch-ready", i)
+    }), await t.boot(), t;
+  }
+  rememberProfile(e) {
+    this.setState({
+      profiles: {
+        ...this.profiles,
+        [e.webId]: e
+      },
+      staleProfiles: De(this.staleProfiles, e.webId)
+    });
+  }
+}
+const g = _e(Ze);
+function et() {
+  me("container_url", (n) => {
+    if (!n.endsWith("/"))
+      return "containerEndingSlashMissing";
+  });
+}
+const tt = {
+  viewBox: "0 0 20 20",
+  width: "1.2em",
+  height: "1.2em"
+};
+function it(n, e) {
+  return d(), p("svg", tt, e[0] || (e[0] = [
+    v("path", {
+      fill: "currentColor",
+      d: "M15 2H5L4 8h12zM0 10s2 1 10 1s10-1 10-1l-4-2H4zm8 4h4v1H8z"
+    }, null, -1),
+    v("circle", {
+      cx: "6",
+      cy: "15",
+      r: "3",
+      fill: "currentColor"
+    }, null, -1),
+    v("circle", {
+      cx: "14",
+      cy: "15",
+      r: "3",
+      fill: "currentColor"
+    }, null, -1)
+  ]));
+}
+const nt = se({ name: "ooui-user-anonymous", render: it }), rt = ["src"], st = /* @__PURE__ */ W({
+  __name: "SolidImage",
+  props: {
+    src: {}
+  },
+  setup(n) {
+    const e = we(async () => {
+      const i = await F.get(n.src) ?? await t(n.src), r = await (i == null ? void 0 : i.blob());
+      return r && URL.createObjectURL(r);
+    });
+    async function t(i) {
+      try {
+        const r = await g.fetch(i);
+        return r.status !== 200 ? null : (await F.store(i, r), F.get(i));
+      } catch {
+        return null;
+      }
+    }
+    return (i, r) => (d(), p("img", { src: l(e) }, null, 8, rt));
+  }
+}), ot = { class: "relative flex items-center justify-center rounded-full bg-gray-200" }, at = {
+  key: 1,
+  class: "text-sm font-semibold tracking-wider text-gray-500",
+  "aria-hidden": "true"
+}, bt = /* @__PURE__ */ W({
+  __name: "SolidAvatar",
+  setup(n) {
+    const e = I(() => {
+      var i;
+      return (((i = g.user) == null ? void 0 : i.name) ?? "").trim().split(" ").map((r) => {
+        var s;
+        return (s = r[0]) == null ? void 0 : s.toUpperCase();
+      }).join("").slice(0, 3);
+    });
+    return (t, i) => {
+      var r, s;
+      return d(), p("div", ot, [
+        (r = t.$solid.user) != null && r.avatarUrl ? (d(), w(st, {
+          key: 0,
+          src: (s = t.$solid.user) == null ? void 0 : s.avatarUrl,
+          alt: "",
+          class: "absolute inset-0 size-full rounded-full"
+        }, null, 8, ["src"])) : e.value ? (d(), p("span", at, L(e.value), 1)) : (d(), w(l(nt), {
+          key: 2,
+          class: "size-6 text-gray-500"
+        }))
+      ]);
+    };
+  }
+}), lt = {
+  viewBox: "0 0 24 24",
+  width: "1.2em",
+  height: "1.2em"
+};
+function ut(n, e) {
+  return d(), p("svg", lt, e[0] || (e[0] = [
+    v("path", {
+      fill: "currentColor",
+      d: "M9 2h9c1.1 0 2 .9 2 2v16c0 1.1-.9 2-2 2H9c-1.1 0-2-.9-2-2v-2h2v2h9V4H9v2H7V4c0-1.1.9-2 2-2"
+    }, null, -1),
+    v("path", {
+      fill: "currentColor",
+      d: "M10.09 15.59L11.5 17l5-5l-5-5l-1.41 1.41L12.67 11H3v2h9.67z"
+    }, null, -1)
+  ]));
+}
+const ct = se({ name: "ic-baseline-log-in", render: ut }), dt = {
+  key: 2,
+  class: "flex w-full justify-center gap-2"
+}, It = /* @__PURE__ */ W({
+  __name: "SolidLogin",
+  props: {
+    class: { default: "" },
+    buttonClass: {},
+    layout: { default: "horizontal" },
+    noLoading: { type: Boolean },
+    allowLegacyAuthenticator: { type: Boolean }
+  },
+  setup(n) {
+    const e = {
+      inrupt: "Log in using Inrupt's authentication library",
+      legacy: "Log in using the legacy authentication library"
+    }, t = pe({
+      url: ve(),
+      authenticator: ye()
+    }), i = Object.keys(e), r = re(!1), s = re(!1), c = I(() => !o.value || s.value), o = I(
+      () => m.development && (!t.url || t.url === "dev" || t.url.trim().length === 0)
+    ), $ = I(() => J("flex flex-col items-center gap-2 w-full md:w-auto", n.class)), _ = I(() => J("w-full whitespace-nowrap", { "md:w-auto": n.layout === "horizontal" && !t.authenticator }, n.buttonClass));
+    function R(a) {
+      return u(
+        `solid.logIn.switchAuthenticator${a.charAt(0).toUpperCase() + a.slice(1)}`,
+        e[a]
+      );
+    }
+    async function le() {
+      if (n.noLoading) {
+        await g.login(t.url, { authenticator: t.authenticator });
+        return;
+      }
+      await x.loading(u("solid.loginOngoing", "Logging in..."), g.login(t.url));
+    }
+    return (a, y) => {
+      const ue = Be("measure");
+      return d(), w(l(Se), {
+        form: l(t),
+        class: C($.value),
+        onSubmit: le
+      }, {
+        default: b(() => [
+          v("div", {
+            class: C(["flex w-full flex-col items-center gap-2", { "md:flex-row": a.layout === "horizontal" && !l(t).authenticator }])
+          }, [
+            c.value ? (d(), w(l(be), {
+              key: 0,
+              name: "url",
+              "aria-label": a.$td("solid.logIn.label", "Login url"),
+              placeholder: a.$td("solid.logIn.placeholder", "https://me.solidcommunity.net"),
+              class: "w-full md:min-w-96"
+            }, null, 8, ["aria-label", "placeholder"])) : M("", !0),
+            l(t).authenticator ? (d(), w(l(Ie), {
+              key: 1,
+              name: "authenticator",
+              class: "w-full max-w-full md:min-w-96",
+              "label-class": "sr-only",
+              "options-class": "md:w-96 w-full max-w-[calc(100vw-4rem)]",
+              label: a.$td("solid.logIn.switchAuthenticatorLabel", "Authentication method"),
+              options: l(i),
+              "render-option": R
+            }, null, 8, ["label", "options"])) : M("", !0),
+            o.value && !s.value ? (d(), p("div", dt, [
+              B(l(k), {
+                variant: "secondary",
+                class: "group gap-0",
+                title: a.$td("solid.logIn.manualUrl", "Enter url"),
+                onClick: y[0] || (y[0] = (Y) => s.value = !0)
+              }, {
+                default: b(() => [
+                  B(l(ct), { class: "size-4" }),
+                  Ve((d(), p("span", {
+                    class: C(["overflow-hidden pl-1 whitespace-nowrap", {
+                      "opacity-0": !r.value,
+                      "w-0 transition-[width] md:group-hover:w-(--width)": r.value
+                    }])
+                  }, [
+                    E(L(a.$td("solid.logIn.manualUrl", "Enter url")), 1)
+                  ], 2)), [
+                    [
+                      ue,
+                      () => r.value = !0,
+                      void 0,
+                      { css: !0 }
+                    ]
+                  ])
+                ]),
+                _: 1
+              }, 8, ["title"]),
+              B(l(k), {
+                disabled: a.noLoading && a.$solid.loginOngoing,
+                submit: "",
+                class: "whitespace-nowrap",
+                onClick: y[1] || (y[1] = (Y) => l(t).url = "dev")
+              }, {
+                default: b(() => [
+                  E(L(a.$td("solid.logIn.dev", "Log in to dev server")), 1)
+                ]),
+                _: 1
+              }, 8, ["disabled"])
+            ])) : (d(), w(l(k), {
+              key: 3,
+              disabled: a.noLoading && a.$solid.loginOngoing,
+              submit: "",
+              class: C(_.value)
+            }, {
+              default: b(() => [
+                E(L(a.$td("solid.logIn.submit", "Log in")), 1)
+              ]),
+              _: 1
+            }, 8, ["disabled", "class"]))
+          ], 2),
+          a.allowLegacyAuthenticator && c.value && !l(t).authenticator ? (d(), w(l(Le), {
+            key: 0,
+            class: "text-sm font-normal text-gray-700",
+            onClick: y[2] || (y[2] = (Y) => l(t).authenticator = "inrupt")
+          }, {
+            default: b(() => [
+              E(L(a.$td("solid.logIn.switchAuthenticator", "Can't log in? Try using a different authentication method")), 1)
+            ]),
+            _: 1
+          })) : M("", !0)
+        ]),
+        _: 1
+      }, 8, ["form", "class"]);
+    };
+  }
+}), ht = { $solid: g };
+function Lt(n = {}) {
+  return {
+    async install(e) {
+      Ue(), Je({ ...Ye, ...n.authenticators ?? {} }), et(), Ge(ae(n.defaultAuthenticator ?? "inrupt")), Ae((t) => {
+        if (t instanceof T)
+          return t.description ? `${t.message} (${t.description})` : t.message;
+      }), typeof n.autoReconnect == "boolean" && (Q.autoReconnect = n.autoReconnect, g.hasPersistedState() || (g.autoReconnect = n.autoReconnect)), n.onUserProfileLoaded && f.on("solid:user-profile-loaded", ([t, i]) => {
+        var r;
+        (r = n.onUserProfileLoaded) == null || r.call(n, t, i);
+      }), await Pe(e, ht);
+    }
+  };
+}
+export {
+  je as AuthenticationCancelledError,
+  T as AuthenticationFailedError,
+  oe as Authenticator,
+  We as ContainerAlreadyInUse,
+  g as Solid,
+  bt as SolidAvatar,
+  st as SolidImage,
+  It as SolidLogin,
+  Ze as SolidService,
+  Ye as authenticators,
+  Lt as default,
+  ae as getAuthenticator,
+  Ke as registerAuthenticator,
+  Je as registerAuthenticators,
+  Ge as setDefaultAuthenticator
+};
+//# sourceMappingURL=aerogel-plugin-solid.js.map