@aerogel/plugin-local-first 0.0.0

package/dist/aerogel-plugin-local-first.js

@@ -0,0 +1,1686 @@
+var ct = Object.defineProperty;
+var dt = (n, t, e) => t in n ? ct(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var g = (n, t, e) => dt(n, typeof t != "symbol" ? t + "" : t, e);
+import { defineServiceState as je, requiredStringProp as ut, computedAsync as ht, Cache as ae, useForm as ft, requiredStringInput as gt, App as S, AGMarkdown as q, AGButton as O, AGForm as mt, AGInput as pt, AGLink as yt, persistent as wt, Events as d, UI as le, translateWithDefault as m, Colors as St, Storage as bt, Errors as X, Job as Ue, Service as vt, replaceExisting as ke, dispatch as ce, bootServices as Mt } from "@aerogel/core";
+import { facade as ne, after as T, required as w, Storage as de, fail as N, tap as K, arrayUnique as Te, objectWithout as ye, asyncMemo as qe, hasLocationQueryParameter as j, getLocationQueryParameter as Q, arrayFilter as Ke, setAsyncMemo as Oe, urlRoot as Ct, requireUrlParse as It, objectWithoutEmpty as Rt, parseBoolean as we, arrayWithout as Ut, arr as Lt, PromisedValue as Pt, JSError as Le, map as v, isInstanceOf as A, arrayRemove as Dt, toString as At, urlRoute as xt, urlResolveDirectory as Et, requireUrlParentDirectory as Z, IndexedDBMap as $t, arrayFrom as kt, arrayChunk as Tt, mixed as Be, objectMap as qt, round as Ot, Semaphore as Ft, isArray as _t } from "@noeldemartin/utils";
+import { SolidTypeIndex as J, SolidContainer as k, SolidACLAuthorization as Ge, SolidDocument as He, SolidEngine as Wt, SolidModel as F, SolidContainsRelation as Ve, isContainerClass as _, Metadata as Nt, Operation as Jt, isContainer as P, Tombstone as W, PropertyOperation as ee } from "soukai-solid";
+import { fetchLoginUserProfile as zt, MalformedSolidDocumentError as Ye } from "@noeldemartin/solid-utils";
+import { setEngine as jt, bootModels as Kt, requireEngine as Bt, DocumentNotFound as Gt } from "soukai";
+import { defineComponent as Pe, createElementBlock as te, openBlock as D, unref as f, computed as Qe, renderSlot as V, createCommentVNode as ue, createVNode as R, createElementVNode as Fe, withCtx as L, createTextVNode as E, toDisplayString as $, createBlock as B, watchEffect as Xe, shallowRef as Ht, triggerRef as he, toRaw as fe } from "vue";
+var Vt = Object.defineProperty, Yt = (n, t, e) => t in n ? Vt(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e, C = (n, t, e) => Yt(n, typeof t != "symbol" ? t + "" : t, e);
+class Qt extends Le {
+}
+function Xt(n, t) {
+  return n;
+}
+class Se extends Le {
+  constructor(t, e, i) {
+    super(Xt(t), i), C(this, "description"), this.description = e;
+  }
+}
+class Zt extends Le {
+  constructor(t, e) {
+    super(`Container at ${t.url} is already in use`, e);
+  }
+}
+const Y = {};
+class Ze {
+  constructor() {
+    C(this, "name"), C(this, "authenticatedFetch"), C(this, "booted"), C(this, "listeners", Lt([])), C(this, "_engine");
+  }
+  get engine() {
+    return this._engine = this._engine ?? new Wt(this.requireAuthenticatedFetch()), this._engine;
+  }
+  getAuthenticatedFetch() {
+    return this.authenticatedFetch ?? null;
+  }
+  requireAuthenticatedFetch() {
+    return this.authenticatedFetch ?? N("Authenticated fetch is not ready");
+  }
+  addListener(t) {
+    return this.listeners.includes(t) || this.listeners.push(t), () => {
+      this.removeListener(t);
+    };
+  }
+  removeListener(t) {
+    this.listeners.includes(t) && this.listeners.remove(t);
+  }
+  async boot() {
+    if (this.booted)
+      return this.booted;
+    this.booted = new Pt(), await this.restoreSession(), this.booted.resolve();
+  }
+  async initAuthenticatedFetch(t) {
+    this.authenticatedFetch = t, await this.notifyListeners("onAuthenticatedFetchReady", t);
+  }
+  async startSession(t) {
+    const e = {
+      authenticator: this,
+      ...t
+    };
+    return await this.notifyListeners("onSessionStarted", e), e;
+  }
+  async failSession(t, e) {
+    await this.notifyListeners("onSessionFailed", t, e);
+  }
+  async endSession() {
+    await this.notifyListeners("onSessionEnded");
+  }
+  async notifyListeners(t, ...e) {
+    await Promise.all(
+      this.listeners.toArray().map(async (i) => {
+        const s = i[t];
+        await (s == null ? void 0 : s(...e));
+      })
+    );
+  }
+}
+const ge = "inrupt-authenticator";
+class ei extends Ze {
+  constructor() {
+    super(...arguments), C(this, "_events"), C(this, "_fetch"), C(this, "_login"), C(this, "_logout"), C(this, "_handleIncomingRedirect");
+  }
+  async login(t) {
+    de.set(ge, t);
+    const e = {
+      oidcIssuer: t
+    };
+    return Y.clientID && (e.clientId = Y.clientID.client_id, e.clientName = Y.clientID.client_name, e.redirectUrl = Y.clientID.redirect_uris[0]), await this._login(e), await T({ seconds: 60 }), N("Browser should have redirected, but it didn't");
+  }
+  async logout() {
+    await this._logout(), await this.endSession();
+  }
+  async restoreSession() {
+    const { events: t, fetch: e, handleIncomingRedirect: i, login: s, logout: o } = await import("./InruptAuthenticator.lazy-BvpQLGoj-BvpQLGoj.js");
+    this._fetch = e, this._login = s, this._logout = o, this._events = t, this._handleIncomingRedirect = i, await this.loginFromRedirect();
+  }
+  async loginFromRedirect() {
+    const t = de.get(ge);
+    if (!t)
+      return;
+    this._events().on("error", (i, s) => {
+      i ?? (i = "Error using Inrupt Authenticator method"), typeof s == "object" ? this.failSession(t, new Se(i, null, { cause: s })) : this.failSession(t, new Se(i, s));
+    });
+    const e = await this._handleIncomingRedirect(globalThis.location.href);
+    de.remove(ge), e != null && e.isLoggedIn && e.webId && await this.initSession(e.webId);
+  }
+  async initSession(t) {
+    await this.initAuthenticatedFetch(this._fetch);
+    try {
+      const e = await y.requireUserProfile(t);
+      await this.startSession({ user: e, loginUrl: t });
+    } catch (e) {
+      await this.failSession(t, e);
+    }
+  }
+}
+class ti extends Ze {
+  constructor() {
+    super(), C(this, "store"), this.store = wt("legacy-authenticator", {});
+  }
+  async login(t, e) {
+    const { SolidAuthClient: i } = await import("./LegacyAuthenticator.lazy-ChFFqP14-ChFFqP14.js");
+    throw this.store.webId = e == null ? void 0 : e.webId, this.store.loginUrl = (e == null ? void 0 : e.oidcIssuerUrl) ?? t, await i.login(this.store.loginUrl) === null ? (delete this.store.webId, delete this.store.loginUrl, new Se("Could not log in with Solid using the legacy authenticator")) : (await T({ seconds: 60 }), new Error("Browser should have redirected, but it didn't"));
+  }
+  async logout() {
+    const { SolidAuthClient: t } = await import("./LegacyAuthenticator.lazy-ChFFqP14-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-ChFFqP14.js"), e = await t.currentSession(), i = w(this.store.loginUrl);
+    await this.initAuthenticatedFetch((s, o) => t.fetch(s, o));
+    try {
+      const s = await y.requireUserProfile(w((e == null ? void 0 : e.webId) ?? this.store.webId));
+      await this.startSession({ user: s, loginUrl: i });
+    } catch (s) {
+      await this.failSession(i, s);
+    }
+  }
+}
+const ii = {};
+new ei(), new ti();
+function si(n) {
+  return ii[n];
+}
+const et = { autoReconnect: !0 }, ni = je({
+  name: "solid",
+  persist: ["autoReconnect", "dismissed", "previousSession", "profiles", "staleProfiles"],
+  initialState: {
+    autoReconnect: et.autoReconnect,
+    dismissed: !1,
+    ignorePreviousSessionError: !1,
+    loginStartupError: null,
+    loginOngoing: !1,
+    preferredAuthenticator: null,
+    previousSession: null,
+    profiles: {},
+    session: null,
+    loginStale: !1,
+    staleProfiles: []
+  },
+  serialize(n) {
+    var t;
+    return ((t = n.previousSession) == null ? void 0 : t.error) instanceof Error && (n.previousSession.error = n.previousSession.error.message), n;
+  },
+  computed: {
+    user: (n) => {
+      var t, e;
+      return ((t = n.session) == null ? void 0 : t.user) ?? ((e = n.previousSession) == null ? void 0 : e.profile) ?? null;
+    },
+    authenticator: (n) => {
+      var t;
+      return ((t = n.session) == null ? void 0 : t.authenticator) ?? null;
+    },
+    fetch() {
+      var n;
+      return ((n = this.authenticator) == null ? void 0 : n.getAuthenticatedFetch()) ?? globalThis.fetch.bind(globalThis);
+    },
+    error(n) {
+      var t;
+      return n.loginStartupError ? n.loginStartupError ?? null : n.ignorePreviousSessionError ? null : ((t = n.previousSession) == null ? void 0 : t.error) ?? null;
+    }
+  }
+});
+class oi extends ni {
+  isLoggedIn() {
+    return !!this.session;
+  }
+  wasLoggedIn() {
+    return !!this.previousSession;
+  }
+  hasLoggedIn() {
+    return !!(this.session || this.previousSession);
+  }
+  requireAuthenticator() {
+    return this.authenticator ?? N("Could not get authenticator");
+  }
+  requireUser() {
+    return this.user ?? N("Could not get user profile (are you logged in?)");
+  }
+  requireUserProfile(t) {
+    return this.getUserProfile(t, { required: !0 });
+  }
+  /* eslint-enable max-len */
+  async getUserProfile(t, e = {}) {
+    var i;
+    let s = null;
+    const o = e.markStale ?? !((i = this.authenticator) != null && i.getAuthenticatedFetch()), r = this.profiles[t] ?? await K(
+      await zt(t, {
+        fetch: this.fetch,
+        required: e.required ?? !1,
+        onLoaded(a) {
+          s = a;
+        }
+      }),
+      async (a) => {
+        a && (s && await d.emit("solid:user-profile-loaded", [a, s]), this.rememberProfile(a));
+      }
+    );
+    return r && o && this.setState({ staleProfiles: Te(this.staleProfiles.concat([r.webId])) }), r;
+  }
+  async refreshUserProfile() {
+    if (!this.isLoggedIn())
+      return;
+    this.setState({ profiles: ye(this.profiles, [this.user.webId]) });
+    const t = await this.requireUserProfile(this.user.webId);
+    this.setState({
+      session: {
+        ...this.session,
+        user: t
+      }
+    });
+  }
+  async login(t, e = {}) {
+    if (S.development && t === "dev" && (t = "http://localhost:3000"), /^https?:\/\//.test(t) || (e.fallbackUrl ?? (e.fallbackUrl = `http://${t}`), t = `https://${t}`), this.isLoggedIn())
+      return !0;
+    if (this.loginOngoing)
+      throw new Error("Authentication already in progress");
+    return e.loading ? le.loading(m("solid.loggingIn", "Logging in..."), () => this.attemptLogin(t, e)) : this.attemptLogin(t, e);
+  }
+  async reconnect(t = {}) {
+    const { force: e, ...i } = t;
+    this.isLoggedIn() || !this.previousSession || this.previousSession.error !== null && !e || await this.login(this.previousSession.loginUrl, {
+      authenticator: this.previousSession.authenticator,
+      ...i,
+      loading: i.loading ?? !1
+    });
+  }
+  async logout(t = !1) {
+    var e, i;
+    const s = !S.plugin("@aerogel/local-first") || !!((e = S.service("$cloud")) != null && e.ready), o = !S.plugin("@aerogel/local-first") || !!((i = S.service("$cloud")) != null && i.dirty), [r, a] = t ? [!0, { wipeLocalData: s }] : await le.confirm(
+      s ? m("solid.logoutConfirmTitle", "Log out from this device?") : m("solid.disconnectConfirmTitle", "Disconnect account?"),
+      s ? o ? m(
+        "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."
+      ) : m(
+        "solid.logoutConfirmMessage",
+        "Logging out will remove all the data from this device, but you'll still have it in your Solid POD."
+      ) : m(
+        "solid.disconnectConfirmMessage",
+        "You'll need to introduce your credentials again to connect to your Solid POD."
+      ),
+      {
+        acceptText: m("solid.logoutConfirmAccept", "Log out"),
+        acceptColor: St.Danger,
+        cancelText: m(
+          "solid.logoutConfirmCancel",
+          m("ui.cancel", "Cancel")
+        ),
+        checkboxes: s ? o ? {
+          wipeLocalData: {
+            label: m(
+              "solid.logoutConfirmWipeNotice",
+              "I understand that changes that haven't been synchronized will be lost."
+            ),
+            default: !1,
+            required: !0
+          }
+        } : void 0 : {
+          wipeLocalData: {
+            label: m(
+              "solid.logoutConfirmWipe",
+              "Also remove all existing data (tasks, lists, etc.)"
+            ),
+            default: !1
+          }
+        }
+      }
+    );
+    r && this.previousSession && await le.loading(m("solid.logoutOngoing", "Logging out..."), async () => {
+      this.setState({
+        dismissed: !1,
+        ignorePreviousSessionError: !1,
+        loginStartupError: null,
+        previousSession: null,
+        ...et
+      }), this.isLoggedIn() && await this.authenticator.logout(), (a.wipeLocalData ?? !0) && await bt.purge(), await d.emit("auth:logout"), await d.emit("auth:after-logout");
+    });
+  }
+  async whenLoggedIn(t) {
+    return this.isLoggedIn() ? t(this.session) : new Promise((e) => {
+      const i = (s) => e(t(s));
+      d.once("auth:login", i);
+    });
+  }
+  dismiss() {
+    this.setState({ dismissed: !0 });
+  }
+  async findOrCreatePrivateTypeIndex() {
+    return await this.findPrivateTypeIndex() ?? await this.createPrivateTypeIndex();
+  }
+  async findPrivateTypeIndex() {
+    const { webId: t, privateTypeIndexUrl: e } = this.requireUser(), i = this.requireAuthenticator().engine;
+    return e ? qe(`${t}-privateTypeIndex`, () => J.withEngine(i).find(e)) : null;
+  }
+  async findOrCreatePublicTypeIndex() {
+    return await this.findPublicTypeIndex() ?? await this.createPublicTypeIndex();
+  }
+  async findPublicTypeIndex() {
+    const { webId: t, publicTypeIndexUrl: e } = this.requireUser(), i = this.requireAuthenticator().engine;
+    return e ? qe(`${t}-publicTypeIndex`, () => J.withEngine(i).find(e)) : null;
+  }
+  async createPrivateContainer(t) {
+    const e = this.requireAuthenticator().engine;
+    return k.withEngine(e, async () => {
+      const i = await k.find(t.url);
+      if (i && !t.reuseExisting)
+        throw new Zt(i);
+      const s = i ?? new k({ url: t.url, name: t.name });
+      if (await s.save(), t.registerFor) {
+        const o = await this.findOrCreatePrivateTypeIndex();
+        await s.register(o, t.registerFor);
+      }
+      return s;
+    });
+  }
+  async boot() {
+    var t, e;
+    await X.booted, j("authenticator") && this.setState({
+      preferredAuthenticator: Q("authenticator")
+    }), j("refreshProfile") && this.setState({
+      staleProfiles: Te(
+        this.staleProfiles.concat(Ke([(t = this.session) == null ? void 0 : t.user.webId, (e = this.previousSession) == null ? void 0 : e.loginUrl]))
+      )
+    }), await this.restorePreviousSession(), await this.startupReconnect();
+  }
+  async createPrivateTypeIndex() {
+    const t = this.requireUser(), e = this.requireAuthenticator(), i = await J.withEngine(e.engine).createPrivate(t);
+    return K(i, () => {
+      t.privateTypeIndexUrl = i.url, Oe(`${t.webId}-privateTypeIndex`, i), this.rememberProfile(t);
+    });
+  }
+  async createPublicTypeIndex() {
+    const t = this.requireUser(), e = this.requireAuthenticator(), i = await J.withEngine(e.engine).createPublic(t);
+    return K(i, () => {
+      t.privateTypeIndexUrl = i.url, Oe(`${t.webId}-publicTypeIndex`, i), this.rememberProfile(t);
+    });
+  }
+  async attemptLogin(t, e) {
+    const i = e.authenticator ?? this.preferredAuthenticator ?? "default", s = e.onError ?? ((a) => S.isMounted() ? X.report(a) : this.setState({ loginStartupError: a })), o = setTimeout(() => this.loginStale = !0, 1e4), r = {
+      dismissed: this.dismissed,
+      ignorePreviousSessionError: this.ignorePreviousSessionError,
+      previousSession: this.previousSession
+    };
+    this.loginOngoing = !0;
+    try {
+      const a = await this.getUserProfile(t, { markStale: !0 }), l = (a == null ? void 0 : a.oidcIssuerUrl) ?? Ct((a == null ? void 0 : a.webId) ?? t), c = await this.bootAuthenticator(i), { domain: u } = It(t);
+      return this.setState({
+        dismissed: !1,
+        ignorePreviousSessionError: !0,
+        previousSession: Rt({
+          profile: a,
+          loginUrl: t,
+          authenticator: i,
+          error: m(
+            "auth.stuckConnecting",
+            `We didn't hear back from the identity provider at \`${u}\`, maybe try reconnecting?`
+          )
+        })
+      }), await d.emit("auth:before-login"), await c.login(l, a), !0;
+    } catch (a) {
+      return this.setState(r), a instanceof Qt ? !1 : e.fallbackUrl ? T().then(() => this.login(e.fallbackUrl ?? "", ye(e, "fallbackUrl"))) : (s(a), !1);
+    } finally {
+      clearTimeout(o), 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 j("autoReconnect") ? we(Q("autoReconnect")) : this.autoReconnect;
+  }
+  forcingReconnect() {
+    return j("autoReconnect") && we(Q("autoReconnect"));
+  }
+  async bootAuthenticator(t) {
+    const e = si(t);
+    return e.addListener({
+      onSessionStarted: async (i) => {
+        this.setState({
+          session: i,
+          previousSession: {
+            authenticator: e.name,
+            loginUrl: i.loginUrl,
+            profile: i.user,
+            error: null
+          }
+        }), this.staleProfiles.includes(i.user.webId) && await this.refreshUserProfile(), S.plugin("@aerogel/local-first") || jt(i.authenticator.engine), Ge.setEngine(i.authenticator.engine), J.setEngine(i.authenticator.engine), He.setEngine(i.authenticator.engine), await d.emit("auth:login", i);
+      },
+      onSessionFailed: async (i, s) => {
+        var o;
+        this.setState({
+          session: null,
+          previousSession: {
+            profile: (o = this.previousSession) == null ? void 0 : o.profile,
+            authenticator: e.name,
+            loginUrl: i,
+            error: s
+          }
+        });
+      },
+      onSessionEnded: () => this.setState({ session: null }),
+      onAuthenticatedFetchReady: (i) => d.emit("auth:fetch-ready", i)
+    }), await e.boot(), e;
+  }
+  rememberProfile(t) {
+    this.setState({
+      profiles: {
+        ...this.profiles,
+        [t.webId]: t
+      },
+      staleProfiles: Ut(this.staleProfiles, t.webId)
+    });
+  }
+}
+const y = ne(oi), ri = ["src"];
+ut();
+const ai = { class: "flex flex-col gap-3" }, li = { class: "flex flex-col" }, ci = {
+  key: 1,
+  class: "mt-1 self-center text-sm text-red-800"
+}, di = /* @__PURE__ */ Pe({
+  __name: "AGSolidStatus",
+  setup(n) {
+    const t = ft({ url: gt() }), e = Qe(
+      () => S.development && (!t.url || t.url === "dev" || t.url.trim().length === 0)
+    );
+    return (i, s) => (D(), te("div", null, [
+      i.$solid.loginStale ? V(i.$slots, "login-stale", { key: 0 }, () => [
+        R(f(q), {
+          text: i.$td("solid.loginStale", "This is taking too long...")
+        }, null, 8, ["text"])
+      ]) : ue("", !0),
+      i.$solid.loginOngoing ? V(i.$slots, "login-ongoing", { key: 1 }, () => [
+        R(f(q), {
+          text: i.$td("ui.loading", "Loading...")
+        }, null, 8, ["text"])
+      ]) : i.$solid.isLoggedIn() ? V(i.$slots, "logged-in", {
+        key: 2,
+        session: i.$solid.session
+      }, () => [
+        Fe("div", ai, [
+          R(f(q), {
+            text: i.$td("solid.loggedIn", "You are logged in as [{userName}]({userWebId})", {
+              userName: i.$solid.user.name ?? i.$solid.user.webId,
+              userWebId: i.$solid.user.webId
+            })
+          }, null, 8, ["text"]),
+          R(f(O), {
+            onClick: s[0] || (s[0] = (o) => i.$solid.logout())
+          }, {
+            default: L(() => [
+              E($(i.$td("solid.logout", "Logout")), 1)
+            ]),
+            _: 1
+          })
+        ])
+      ]) : V(i.$slots, "logged-out", { key: 3 }, () => {
+        var o;
+        return [
+          Fe("div", li, [
+            R(f(mt), {
+              form: f(t),
+              class: "flex",
+              onSubmit: s[2] || (s[2] = (r) => i.$solid.login(f(t).url))
+            }, {
+              default: L(() => [
+                R(f(pt), {
+                  name: "url",
+                  "aria-label": i.$td("solid.url", "Login url"),
+                  placeholder: i.$td("solid.placeholder", "https://...")
+                }, null, 8, ["aria-label", "placeholder"]),
+                e.value ? (D(), B(f(O), {
+                  key: 0,
+                  submit: "",
+                  onClick: s[1] || (s[1] = (r) => f(t).url = "dev")
+                }, {
+                  default: L(() => [
+                    E($(i.$td("solid.devLogin", "Dev login")), 1)
+                  ]),
+                  _: 1
+                })) : (D(), B(f(O), {
+                  key: 1,
+                  submit: ""
+                }, {
+                  default: L(() => [
+                    E($(i.$td("solid.login", "Login")), 1)
+                  ]),
+                  _: 1
+                }))
+              ]),
+              _: 1
+            }, 8, ["form"]),
+            i.$solid.wasLoggedIn() ? (D(), B(f(O), {
+              key: 0,
+              class: "mt-3",
+              onClick: s[3] || (s[3] = (r) => i.$solid.reconnect({ force: !0 }))
+            }, {
+              default: L(() => [
+                E($(i.$td("solid.reconnect", "Reconnect")), 1)
+              ]),
+              _: 1
+            })) : ue("", !0),
+            (o = i.$solid.previousSession) != null && o.error || i.$solid.loginStartupError ? (D(), te("p", ci, [
+              R(f(q), {
+                text: i.$td("solid.previousLoginError", "Previous login attempt failed"),
+                inline: ""
+              }, null, 8, ["text"]),
+              R(f(yt), {
+                onClick: s[4] || (s[4] = (r) => {
+                  var a;
+                  return i.$errors.inspect(((a = i.$solid.previousSession) == null ? void 0 : a.error) || i.$solid.loginStartupError);
+                })
+              }, {
+                default: L(() => [
+                  E(" (" + $(i.$td("errors.viewDetails", "View details")) + ") ", 1)
+                ]),
+                _: 1
+              })
+            ])) : ue("", !0)
+          ])
+        ];
+      })
+    ]));
+  }
+});
+let De = /* @__PURE__ */ new WeakMap();
+function ui(n) {
+  const t = Ht(v([], "id")), e = Qe(() => t.value.getItems()), i = /* @__PURE__ */ new Set([n.collection]), s = {
+    modelsMap: t,
+    modelsArray: e,
+    collectionsSet: i,
+    async refresh() {
+      const o = v([], "id");
+      for (const r of i)
+        (await n.withCollection(r, () => n.all())).forEach((a) => o.add(a));
+      t.value = o;
+    }
+  };
+  return De.set(n, s), n.on("created", (o) => (t.value.add(fe(o)), he(t))), n.on("deleted", (o) => (t.value.delete(fe(o)), he(t))), n.on("updated", (o) => (t.value.add(fe(o)), he(t))), d.on("purge-storage", () => t.value = v([], "id")), d.on("cloud:migration-completed", () => s.refresh()), d.on("cloud:migration-cancelled", () => s.refresh()), d.on("cloud:backup-completed", () => s.refresh()), s;
+}
+function Ae() {
+  return De;
+}
+function hi(n) {
+  return De.get(n) ?? ui(n);
+}
+function xe(n) {
+  var t;
+  return ((t = Ae().get(n)) == null ? void 0 : t.modelsArray.value) ?? [];
+}
+function fi(n, t) {
+  w(
+    Ae().get(n),
+    "Failed ignoring models collection, please track the model first using trackModels()"
+  ).collectionsSet.delete(t);
+}
+async function ie(n, t, e = {}) {
+  const i = e.refresh ?? !0, s = w(
+    Ae().get(n),
+    "Failed tracking models collection, please track the model first using trackModels()"
+  );
+  if (!s.collectionsSet.has(t) && (s.collectionsSet.add(t), i)) {
+    const o = s.modelsArray.value;
+    (await n.withCollection(t, () => n.all())).forEach((r) => o.push(r)), s.modelsMap.value = v(o, "id");
+  }
+}
+async function gi(n, t) {
+  const { service: e, property: i, transform: s, ...o } = t ?? {}, r = s ?? ((l) => l), a = hi(n);
+  for (const [l, c] of Object.entries(o))
+    n.on(l, c);
+  e && i && Xe(() => e.setState(i, r(a.modelsArray.value))), await a.refresh();
+}
+const me = /* @__PURE__ */ new WeakMap();
+function be(n) {
+  return Ke(
+    M(n).map((t) => {
+      const e = n.instance().requireRelation(t).relatedClass;
+      return _(e) ? !1 : e;
+    })
+  );
+}
+function M(n) {
+  return me.has(n) || me.set(
+    n,
+    n.relations.filter((t) => F.reservedRelations.includes(t) ? !1 : n.instance().requireRelation(t) instanceof Ve)
+  ), me.get(n) ?? [];
+}
+function tt(n) {
+  return M(n.static()).reduce(
+    (e, i) => e.concat(n.getRelationModels(i) ?? []),
+    []
+  );
+}
+function _e(n) {
+  const t = /* @__PURE__ */ new Set(), e = n.instance();
+  t.add(n);
+  for (const i of n.relations)
+    n.reservedRelations.includes(i) || t.add(e.requireRelation(i).relatedClass);
+  return [...t.values()];
+}
+function ve(n) {
+  return n.getRelatedModels().filter(
+    (t) => !A(t, Ge) && !A(t, He) && !A(t, Nt) && !A(t, Jt) && t.static() !== k
+  );
+}
+function it(n) {
+  if (n.isDirty())
+    return !0;
+  if (!(n instanceof k))
+    return !1;
+  const t = (e) => {
+    var i;
+    return (i = n.getRelationModels(e)) == null ? void 0 : i.some((s) => it(s));
+  };
+  return M(n.static()).some(t);
+}
+const mi = w(() => S.service("$cloud"));
+class pi {
+  constructor() {
+    g(this, "models", /* @__PURE__ */ new Set());
+    g(this, "promises", []);
+  }
+  push(t) {
+    this.models.add(t), this.syncAfter(T({ seconds: 1 }));
+  }
+  clear(t) {
+    if (!t) {
+      this.models = /* @__PURE__ */ new Set();
+      return;
+    }
+    for (const e of t)
+      this.models.delete(e);
+  }
+  async syncAfter(t) {
+    const e = typeof t == "function" ? t() : t;
+    return this.promises.push(e), e.then(() => Dt(this.promises, e)), this.promises.length === 1 && this.schedule(), e;
+  }
+  schedule() {
+    Promise.all(this.promises).then(() => T()).then(() => {
+      if (this.promises.length !== 0) {
+        this.schedule();
+        return;
+      }
+      const t = this.consume();
+      t.length !== 0 && mi.syncIfOnline(t);
+    });
+  }
+  consume() {
+    const t = [], e = /* @__PURE__ */ new Set();
+    for (const i of this.models)
+      P(i) && (this.models.delete(i), tt(i).forEach((s) => e.add(s)), t.push(i));
+    for (const i of this.models)
+      this.models.delete(i), !e.has(i) && t.push(i);
+    return t;
+  }
+}
+const se = ne(pi), h = w(() => S.service("$cloud")), st = /* @__PURE__ */ new WeakMap(), Ee = /* @__PURE__ */ new WeakMap();
+function yi(n) {
+  const t = n.getRelatedModels().concat([n]);
+  for (const e of t)
+    e.cleanDirty(!0);
+}
+function wi(n) {
+  const t = ve(n).concat([n]);
+  for (const e of t) {
+    if (!e.operations || e.operations.length === 0)
+      continue;
+    const i = (e.operations ?? []).filter((s) => !(s instanceof ee) || !e.ignoreRdfPropertyHistory(s.property, !0));
+    if (!i.some((s) => !s.isInception(e))) {
+      e.setRelationModels("operations", []);
+      continue;
+    }
+    e.setRelationModels("operations", i);
+  }
+}
+async function We(n) {
+  h.setState({
+    localModelUpdates: {
+      ...h.localModelUpdates,
+      [n.url]: 1
+    }
+  }), Ui(n.static()) && await Me(n.static(), Z(n.url)), h.autoPush && h.ready && !h.syncing && se.push(n);
+}
+async function Me(n, t) {
+  var e;
+  (e = h.modelCollections[n.modelName]) != null && e.includes(t) || (h.setState("modelCollections", {
+    ...h.modelCollections,
+    [n.modelName]: (h.modelCollections[n.modelName] ?? []).concat(t)
+  }), await ie(n, t));
+}
+async function Ne(n) {
+  if (Si(n))
+    return;
+  const t = h.localModelUpdates[n.url] ?? 0;
+  h.setState({
+    localModelUpdates: n.isSoftDeleted() ? ye(h.localModelUpdates, n.url) : {
+      ...h.localModelUpdates,
+      [n.url]: t + 1
+    }
+  }), h.autoPush && h.ready && !h.syncing && se.push(n);
+}
+function Ce(n, t) {
+  const e = n == null ? void 0 : n.map((s) => At(s.getDeletedPrimaryKey() ?? s.getPrimaryKey())), i = {};
+  for (const [s, o] of Object.entries(h.localModelUpdates)) {
+    const r = xt(s);
+    (!e || e.some(
+      (l) => s === l || l.endsWith("/") && s.startsWith(l)
+    )) && !(t != null && t.has(r)) || (i[s] = o);
+  }
+  h.setState({ localModelUpdates: i });
+}
+function $e(n, t = {}) {
+  const e = /* @__PURE__ */ new Set();
+  if (e.add(n.static()), n instanceof k)
+    for (const s of M(n.static()))
+      e.add(n.requireRelation(s).relatedClass);
+  const i = [...e.values()].map(
+    (s) => [s, x(s)]
+  );
+  return K(n.clone({ constructors: i }), (s) => {
+    wi(s), t.clean && yi(s);
+  });
+}
+function nt(n) {
+  const t = /* @__PURE__ */ new Set();
+  if (t.add(n.static()), n instanceof k)
+    for (const i of M(n.static()))
+      t.add(n.requireRelation(i).relatedClass);
+  const e = [...t.values()].map(
+    (i) => [i, Pi(i)]
+  );
+  return n.clone({ constructors: e });
+}
+async function Je(n, t, e) {
+  const i = x(W), s = t.map((a) => a.url), o = n.filter((a) => !s.includes(a.url)).map((a) => a.requireDocumentUrl()).filter((a) => !e.has(a)), r = await i.all({ $in: o });
+  return t.concat(r);
+}
+function Si(n) {
+  var e;
+  const t = (e = n.metadata.updatedAt) == null ? void 0 : e.getTime();
+  return !n.operations.some((i) => i.date.getTime() !== t ? !1 : i instanceof ee ? !n.ignoreRdfPropertyHistory(i.property, !0) : !0);
+}
+function bi(n, t) {
+  return t.get(n.url) ?? nt(n);
+}
+function Ie() {
+  return [...h.registeredModels].map(({ modelClass: n }) => xe(n)).flat();
+}
+function vi() {
+  return h.schemaMigrations;
+}
+function Mi() {
+  h.schemaMigrations.clear();
+}
+function ze(n) {
+  return h.schemaMigrations.get(n);
+}
+function x(n) {
+  return st.get(n) ?? Li(n);
+}
+function pe(n) {
+  const t = y.requireUser().storageUrls[0];
+  return n ? Et((n.startsWith("/") ? t.slice(0, -1) : t) + n) : t;
+}
+function Ci(n, t) {
+  return t.get(n.url) ?? $e(n);
+}
+function Ii(n) {
+  for (const { modelClass: t } of h.registeredModels)
+    if (xe(t).some((i) => i.url === n.url))
+      return !0;
+  return !1;
+}
+function Re(n) {
+  return Ee.has(n.static());
+}
+function Ri(n) {
+  return !Re(n);
+}
+function Ui(n) {
+  return h.registeredModels.some(({ modelClass: t }) => t === n);
+}
+function Li(n) {
+  var s;
+  const t = n, e = (o, r) => {
+    o.timestamps = t.timestamps, o.history = t.history, r(), o.timestamps = [], o.history = !1;
+  }, i = (s = class extends t {
+    initialize(o, r) {
+      e(this._proxy.static(), () => super.initialize(o, r));
+    }
+    initializeRelations() {
+      super.initializeRelations();
+      for (const o of Object.values(this._relations))
+        o instanceof Ve && (o.relatedClass = x(o.relatedClass));
+    }
+    fixMalformedAttributes() {
+      e(this.static(), () => super.fixMalformedAttributes());
+    }
+  }, g(s, "timestamps", !1), g(s, "history", !1), s);
+  return st.set(t, i), Ee.set(i, t), t.on("schema-updated", async (o) => {
+    await i.updateSchema({
+      ...o,
+      timestamps: !1,
+      history: !1
+    });
+  }), Kt({ [`Remote${n.modelName}`]: i }), i;
+}
+function Pi(n) {
+  return Ee.get(n) ?? N(`Couldn't find local class for ${n.modelName}`);
+}
+class Di extends Ue {
+  constructor() {
+    super(...arguments);
+    g(this, "urlMigrations", []);
+    g(this, "collectionMigrations", []);
+  }
+  migrateUrl(e, i, s) {
+    this.urlMigrations.push({
+      modelClass: e,
+      local: i,
+      remote: s
+    });
+  }
+  migrateCollection(e, i, s) {
+    this.collectionMigrations.push({
+      modelClass: e,
+      local: i,
+      remote: s
+    });
+  }
+  async run() {
+    const e = Bt(), i = await e.getCollections();
+    for (const s of i) {
+      const o = await e.readMany(s);
+      for (const [r, a] of Object.entries(o)) {
+        const l = this.replaceUrl(r);
+        await e.create(Z(l), this.replaceDocumentUrls(a), l), await e.delete(s, r);
+      }
+    }
+    for (const { modelClass: s, remote: o } of this.urlMigrations)
+      ie(s, Z(o), { refresh: !1 });
+    for (const { modelClass: s, local: o, remote: r } of this.collectionMigrations)
+      fi(s, o), ie(s, r, { refresh: !1 });
+  }
+  replaceDocumentUrls(e) {
+    for (const [i, s] of Object.entries(e)) {
+      if (i === "@id" && typeof s == "string") {
+        e[i] = this.replaceUrl(s);
+        continue;
+      }
+      typeof s != "object" || s === null || (e[i] = this.replaceDocumentUrls(s));
+    }
+    return e;
+  }
+  replaceUrl(e) {
+    for (const { local: i, remote: s } of this.urlMigrations)
+      if (e.startsWith(i))
+        return e.replace(i, s);
+    for (const { local: i, remote: s } of this.collectionMigrations)
+      if (e.startsWith(i))
+        return e.replace(i, s);
+    return e;
+  }
+}
+class Ai extends vt {
+  constructor() {
+    super(...arguments);
+    g(this, "cache", new $t("documents-cache"));
+  }
+  async isFresh(e, i) {
+    const s = await this.cache.get(e), o = typeof i != "number" ? i.getTime() : i;
+    return !!(s != null && s.modifiedAt) && s.modifiedAt >= o;
+  }
+  async remember(e, i) {
+    await this.cache.set(e, {
+      modifiedAt: typeof i != "number" ? i.getTime() : i
+    });
+  }
+  async forget(e) {
+    await this.cache.delete(e);
+  }
+  async boot() {
+    d.on("auth:logout", async () => {
+      await this.cache.clear(), this.cache.close();
+    });
+  }
+}
+const G = ne(Ai);
+function xi(n) {
+  const t = {};
+  return async () => ("value" in t || (t.value = await n()), t.value);
+}
+class ot {
+  async loadContainedModels(t, e = {}) {
+    var u;
+    if (Ri(t)) {
+      const p = [];
+      for (const I of M(t.static())) {
+        const U = await t.loadRelationIfUnloaded(I) ?? [];
+        p.push(...kt(U));
+      }
+      return p;
+    }
+    const i = {}, s = [], o = v(t.documents, "url"), r = Tt(t.resourceUrls, 10), a = r.flat().map((p) => ({
+      documentUrl: p,
+      completed: !1
+    })), l = v(a, "documentUrl");
+    e.status && (e.status.children = a);
+    for (const p of r) {
+      await Promise.all(
+        p.map(async (I) => {
+          const { children: U, tombstones: H } = await this.loadDocumentChildren(t, I, o, e.onMalformedDocument);
+          s.push(...H);
+          for (const [re, lt] of Object.entries(U))
+            (i[re] ?? (i[re] = [])).push(...lt);
+        })
+      );
+      for (const I of p)
+        I.endsWith("/") || (w(l.get(I)).completed = !0);
+      await ((u = e.onLoaded) == null ? void 0 : u.call(e, p));
+    }
+    for (const [p, I] of Object.entries(i))
+      t.setRelationModels(p, I);
+    const c = e.ignoreTombstones ? Object.values(i).flat() : Object.values(i).flat().concat(s);
+    return e.status && (e.status.children = c.map((p) => w(l.get(p.requireDocumentUrl())))), c;
+  }
+  async loadDocumentChildren(t, e, i, s) {
+    var r;
+    const o = i.get(e);
+    return o && await G.isFresh(o.url, o.updatedAt ?? /* @__PURE__ */ new Date()) && ((r = this.localModels) != null && r.hasKey(t.url)) ? {
+      children: await this.loadDocumentChildrenFromLocal(t, o),
+      tombstones: []
+    } : this.loadDocumentChildrenFromRemote(t, e, s);
+  }
+  async loadDocumentChildrenFromLocal(t, e) {
+    var s, o;
+    const i = {};
+    for (const r of M(t.static())) {
+      const a = t.requireRelation(r);
+      if (a.loaded) {
+        i[r] = a.getLoadedModels();
+        continue;
+      }
+      const l = ((o = (s = this.localModels) == null ? void 0 : s.get(t.url)) == null ? void 0 : o.getRelationModels(r)) ?? [];
+      i[r] = l.filter((c) => c.getDocumentUrl() === e.url).map((c) => $e(c, { clean: !0 }));
+    }
+    return i;
+  }
+  async loadDocumentChildrenFromRemote(t, e, i) {
+    const s = {}, o = [], r = xi(async () => {
+      try {
+        const a = await t.requireEngine().readOne(t.static("collection"), e), l = await W.createManyFromEngineDocuments({
+          [e]: a
+        });
+        return o.push(...l), a;
+      } catch (a) {
+        if (A(a, Gt))
+          return null;
+        if (A(a, Ye))
+          return console.warn(a.message), await (i == null ? void 0 : i(e)), null;
+        throw a;
+      }
+    });
+    for (const a of M(t.static())) {
+      const l = t.requireRelation(a);
+      if (l.loaded) {
+        s[a] = l.getLoadedModels();
+        continue;
+      }
+      const c = await r();
+      if (!c)
+        continue;
+      const u = await l.relatedClass.createManyFromEngineDocuments({
+        [e]: c
+      });
+      s[a] = u;
+    }
+    return { children: s, tombstones: o };
+  }
+}
+const z = /* @__PURE__ */ new WeakMap();
+class rt {
+  async loadTypeIndex(t = {}) {
+    const e = y.requireUser();
+    return t.create && !z.get(e) ? z.set(e, await y.findOrCreatePrivateTypeIndex()) : z.has(e) || z.set(e, await y.findPrivateTypeIndex()), z.get(e) ?? null;
+  }
+}
+class at {
+  async indexLocalModels(t) {
+    for (const e of t)
+      await this.addLocalModel(e);
+  }
+  async addLocalModel(t) {
+    if (!(!this.localModels || this.localModels.hasKey(t.url))) {
+      this.localModels.add(t);
+      for (const e of M(t.static()))
+        await t.loadRelationIfUnloaded(e);
+      for (const e of t.getRelatedModels())
+        await this.addLocalModel(e);
+    }
+  }
+}
+const Ei = Ue;
+class oe extends Be(Ei, [ot, rt, at]) {
+  constructor() {
+    super(...arguments);
+    g(this, "_models");
+  }
+  static restore(e) {
+    return K(new oe(), (i) => {
+      i.status = e;
+    });
+  }
+  get models() {
+    return this._models;
+  }
+  set models(e) {
+    if (!e) {
+      delete this._models, delete this.localModels;
+      return;
+    }
+    const i = qt(this.status.children ?? [], "modelUrl");
+    this._models = e, this.localModels = v([], "url"), this.status.children = e.map(
+      (s) => i[s.url] ?? {
+        modelUrl: s.url,
+        completed: !1
+      }
+    );
+  }
+  async run() {
+    if (!this.models)
+      throw new Error("Cant start migration without models");
+    await this.indexLocalModels(this.models);
+    const e = this.status.children ?? [], i = await this.loadTypeIndex();
+    for (const s of e) {
+      const o = this.models.find(({ url: r }) => s.modelUrl === r);
+      !o || s.completed || (await this.migrateRegisteredModel(o, s, i), await this.updateProgress(() => s.completed = !0));
+    }
+    for (const [s, o] of vi())
+      await s.updateSchema(o);
+    Mi();
+  }
+  async migrateRegisteredModel(e, i, s) {
+    if (await this.migrate(e, i), !P(e))
+      return;
+    const o = be(e.static()), r = s == null ? void 0 : s.registrations.find(({ instanceContainer: a }) => a === e.url);
+    !s || !r || o.length === 0 || (r.setAttribute(
+      "forClass",
+      o.map((a) => {
+        var l;
+        return ((l = ze(a)) == null ? void 0 : l.rdfsClasses) ?? a.rdfsClass;
+      }).flat()
+    ), await s.save());
+  }
+  async migrate(e, i) {
+    this.assertNotCancelled(), await this.migrateChildren(e, i);
+    const s = ze(e.static());
+    if (!s)
+      return;
+    const o = await x(e.static()).find(e.url), r = await (o == null ? void 0 : o.migrateSchema(s));
+    await e.migrateSchema(s, {
+      mintOperationUrl: (a) => {
+        var l, c;
+        return (c = (l = r == null ? void 0 : r.operations) == null ? void 0 : l.find((u) => !A(a, ee) || !A(u, ee) ? !1 : a.property === u.property && a.date.getTime() === u.date.getTime())) == null ? void 0 : c.url;
+      }
+    });
+  }
+  async migrateChildren(e, i) {
+    if (!P(e))
+      return;
+    const s = await this.loadContainedModels(e, { ignoreTombstones: !0 });
+    i.children ?? (i.children = s.map((o) => ({
+      modelUrl: o.url,
+      completed: !1
+    })));
+    for (const o of i.children) {
+      const r = s.find(({ url: a }) => o.modelUrl === a);
+      !r || o.completed || (await this.migrate(r, o), await this.updateProgress(() => o.completed = !0));
+    }
+  }
+}
+const $i = w(() => S.service("$cloud")), ki = Ue;
+function Ti(n) {
+  return !!n && "root" in n;
+}
+class qi extends Be(ki, [ot, rt, at]) {
+  constructor(e) {
+    super();
+    g(this, "models");
+    g(this, "dirtyRemoteModels");
+    g(this, "rootLocalModels");
+    g(this, "tombstones");
+    g(this, "malformedDocuments");
+    g(this, "documentsModifiedAt");
+    g(this, "localModels");
+    this.models = e, this.rootLocalModels = [], this.localModels = v([], "url"), this.tombstones = v([], "resourceUrl"), this.malformedDocuments = /* @__PURE__ */ new Set(), this.documentsModifiedAt = {};
+  }
+  async run() {
+    const e = y.requireAuthenticator().engine, i = (o, { headers: r }) => {
+      const a = r == null ? void 0 : r.get("last-modified");
+      !a || o.endsWith("/") || (this.documentsModifiedAt[o] = new Date(a));
+    }, s = e.listeners.add({
+      onDocumentRead: i,
+      onDocumentUpdated: i
+    });
+    try {
+      this.rootLocalModels = this.models ?? Ie(), await this.indexLocalModels(this.rootLocalModels), await this.pullChanges(), await this.pushChanges();
+    } finally {
+      s();
+    }
+  }
+  getInitialStatus() {
+    return {
+      root: !0,
+      completed: !1,
+      children: [{ completed: !1 }, { completed: !1 }]
+    };
+  }
+  calculateCurrentProgress(e) {
+    return e ?? (e = this.status), Ti(e) ? Ot(
+      this.calculateCurrentProgress(e.children[0]) * 0.9 + this.calculateCurrentProgress(e.children[1]) * 0.1,
+      2
+    ) : super.calculateCurrentProgress(e);
+  }
+  async pullChanges() {
+    const e = this.models ? await this.fetchRemoteModelsForLocal(this.models) : await this.fetchRemoteModels(), i = v(e, (s) => s instanceof W ? s.resourceUrl : s.url);
+    this.dirtyRemoteModels = await this.synchronizeModels(i), await this.updateProgress((s) => s.children[0].completed = !0);
+  }
+  async pushChanges() {
+    const e = this.dirtyRemoteModels ?? [], i = this.status.children[1].children = e.map(() => ({ completed: !1 }));
+    for (let s = 0; s < e.length; s++) {
+      const o = e[s], r = i[s];
+      if (o.isSoftDeleted()) {
+        o.enableHistory(), o.enableTombstone(), await o.delete(), await this.updateProgress(() => r.completed = !0);
+        return;
+      }
+      await this.saveModelAndChildren(o, r), await this.updateTypeRegistrations(o), await this.updateProgress(() => r.completed = !0);
+    }
+    for (const [s, o] of Object.entries(this.documentsModifiedAt))
+      await G.remember(s, o);
+    Ce(this.models, this.malformedDocuments), await this.updateProgress((s) => s.children[1].completed = !0);
+  }
+  async fetchRemoteModels() {
+    const e = this.status.children[0], i = await this.loadTypeIndex();
+    if (!i)
+      return [];
+    const s = [], o = /* @__PURE__ */ new Set(), r = [...$i.registeredModels].map(({ modelClass: l }) => {
+      const c = _(l) ? be(l) : [];
+      return {
+        modelClass: l,
+        rdfsClasses: c.length > 0 ? c.map((u) => u.rdfsClasses).flat() : l.rdfsClasses
+      };
+    }), a = i.registrations.map((l) => {
+      const c = r.find(
+        ({ rdfsClasses: u }) => !!l.instanceContainer && u.some((p) => l.forClass.includes(p))
+      );
+      return !c || !l.instanceContainer || o.has(l.instanceContainer) ? null : (o.add(l.instanceContainer), [l, c]);
+    }).filter((l) => !!l);
+    e.children = a.map(() => ({ completed: !1 }));
+    for (let l = 0; l < a.length; l++)
+      await this.ignoringMalformedDocumentErrors(async () => {
+        var I;
+        const c = w(a[l])[0], u = w(a[l])[1], p = x(u.modelClass);
+        if (c.instanceContainer) {
+          if (_(p)) {
+            await Me(
+              u.modelClass,
+              Z(c.instanceContainer)
+            );
+            const U = await p.find(c.instanceContainer);
+            U && (await this.loadChildren(U, w((I = e.children) == null ? void 0 : I[l])), s.push(U)), await this.updateProgress(() => {
+              var H;
+              return w((H = e.children) == null ? void 0 : H[l]).completed = !0;
+            });
+            return;
+          }
+          await Me(u.modelClass, c.instanceContainer), s.push(...await p.from(c.instanceContainer).all()), await this.updateProgress(() => {
+            var U;
+            return w((U = e.children) == null ? void 0 : U[l]).completed = !0;
+          });
+        }
+      });
+    return Je(this.rootLocalModels, s, this.malformedDocuments);
+  }
+  async fetchRemoteModelsForLocal(e) {
+    const i = [], s = this.status.children[0].children = e.map(() => ({ completed: !1 }));
+    for (let o = 0; o < e.length; o++)
+      await this.ignoringMalformedDocumentErrors(async () => {
+        const r = e[o], a = s[o], l = await x(r.static()).find(r.url);
+        if (!l) {
+          await this.updateProgress(() => a.completed = !0);
+          return;
+        }
+        P(l) && await this.loadChildren(l, a), i.push(l), await this.updateProgress(() => a.completed = !0);
+      });
+    return Je(e, i, this.malformedDocuments);
+  }
+  async updateTypeRegistrations(e) {
+    if (!P(e) || !Ii(e))
+      return;
+    const i = be(e.static());
+    if (i.length === 0)
+      return;
+    const s = await this.loadTypeIndex({ create: !0 });
+    s.registrations.some((o) => o.instanceContainer === e.url) || await e.register(s, i);
+  }
+  async loadChildren(e, i) {
+    var o, r;
+    if (this.assertNotCancelled(), !P(e))
+      return;
+    const s = await this.loadContainedModels(e, {
+      status: i,
+      onLoaded: async () => {
+        this.assertNotCancelled(), await this.updateProgress();
+      },
+      onMalformedDocument: (a) => this.malformedDocuments.add(a)
+    });
+    for (let a = 0; a < s.length; a++) {
+      const l = s[a];
+      if (l instanceof W) {
+        this.tombstones.add(l);
+        continue;
+      }
+      if (this.tombstones.hasKey(l.url)) {
+        await this.deleteChild(e, l);
+        continue;
+      }
+      await this.loadChildren(l, (o = i == null ? void 0 : i.children) == null ? void 0 : o[a]), (r = i == null ? void 0 : i.children) != null && r[a] && await this.updateProgress(() => {
+        var c;
+        return w((c = i.children) == null ? void 0 : c[a]).completed = !0;
+      });
+    }
+  }
+  async deleteChild(e, i) {
+    for (const s of e.static("relations")) {
+      const o = e.requireRelation(s);
+      if (o.related) {
+        if (Array.isArray(o.related)) {
+          o.related = o.related.filter((r) => r !== i);
+          continue;
+        }
+        if (o.related === i) {
+          o.related = null;
+          continue;
+        }
+      }
+    }
+    await i.delete();
+  }
+  async saveModelAndChildren(e, i) {
+    if (this.assertNotCancelled(), Re(e) && e.isSoftDeleted()) {
+      e.enableHistory(), e.enableTombstone(), await e.delete();
+      return;
+    }
+    if (this.malformedDocuments.has(e.requireDocumentUrl()))
+      return;
+    if (await e.save(), !P(e)) {
+      if (Re(e)) {
+        const r = e.requireDocumentUrl(), a = this.documentsModifiedAt[r] ?? /* @__PURE__ */ new Date();
+        await G.remember(r, a), delete this.documentsModifiedAt[r];
+      }
+      return;
+    }
+    const s = M(e.static()).map((r) => e.getRelationModels(r) ?? []).flat(), o = i ? s.map(() => ({ completed: !1 })) : [];
+    i && (i.children = o);
+    for (let r = 0; r < s.length; r++) {
+      const a = s[r], l = o[r];
+      await this.saveModelAndChildren(a, l), l && await this.updateProgress(() => l.completed = !0);
+    }
+  }
+  async synchronizeModels(e) {
+    const i = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+    for (const r of e.items()) {
+      if (r instanceof W) {
+        const l = this.localModels.get(r.resourceUrl);
+        l && (await l.delete(), s.add(l));
+        continue;
+      }
+      const a = bi(r, this.localModels);
+      await this.loadChildren(a), await F.synchronize(a, r), await this.reconcileInconsistencies(a, r), await this.saveModelAndChildren(a), await this.addLocalModel(a), this.rootLocalModels.push(a), i.add(a.url);
+    }
+    for (const r of this.rootLocalModels) {
+      if (s.has(r) || i.has(r.url))
+        continue;
+      await this.loadChildren(r);
+      const a = Ci(r, e);
+      await F.synchronize(r, a), e.add(a);
+    }
+    const o = [];
+    for (const r of e.getItems()) {
+      if (it(r)) {
+        o.push(r);
+        continue;
+      }
+      await this.rememberModelDocuments(r);
+    }
+    return o;
+  }
+  async reconcileInconsistencies(e, i, s) {
+    e.rebuildAttributesFromHistory(), e.setAttributes(i.getAttributes(!0)), s ?? (s = /* @__PURE__ */ new Set()), s.add(e);
+    for (const r of M(e.static()))
+      await this.synchronizeContainerDocuments(
+        e.requireRelation(r),
+        i.requireRelation(r)
+      );
+    const o = v(ve(i), "url");
+    for (const r of ve(e))
+      s.has(r) || !r.isRelationLoaded("operations") || !o.hasKey(r.url) || await this.reconcileInconsistencies(r, o.require(r.url));
+    e.isDirty() && (await e.save(), await F.synchronize(e, i));
+  }
+  async synchronizeContainerDocuments(e, i) {
+    const s = v(e.related ?? [], "url"), o = v(i.related ?? [], "url"), r = s.getKeys().filter((l) => !o.hasKey(l) && !o.hasKey(encodeURI(l))), a = o.getKeys().filter((l) => !s.hasKey(l) && !s.hasKey(encodeURI(l)));
+    for (const l of r) {
+      const c = s.require(l), u = $e(c);
+      i.addRelated(u), o.add(u);
+    }
+    for (const l of a) {
+      const c = o.require(l), u = nt(c);
+      e.addRelated(u), s.add(u);
+    }
+    for (const l of s.items()) {
+      const c = o.require(l.url);
+      await F.synchronize(l, c), await this.saveModelAndChildren(l);
+    }
+  }
+  async rememberModelDocuments(e) {
+    if (!P(e)) {
+      const s = e.requireDocumentUrl(), o = this.documentsModifiedAt[s] ?? /* @__PURE__ */ new Date();
+      await G.remember(s, o), delete this.documentsModifiedAt[s];
+      return;
+    }
+    const i = M(e.static()).map((s) => e.getRelationModels(s) ?? []).flat();
+    for (const s of i)
+      await this.rememberModelDocuments(s);
+  }
+  async ignoringMalformedDocumentErrors(e) {
+    try {
+      await e();
+    } catch (i) {
+      if (A(i, Ye)) {
+        console.warn(i.message), i.documentUrl && this.malformedDocuments.add(i.documentUrl);
+        return;
+      }
+      throw i;
+    }
+  }
+}
+const b = {
+  Disconnected: "disconnected",
+  Online: "online",
+  Syncing: "syncing",
+  Migrating: "migrating"
+}, Oi = je({
+  name: "cloud",
+  persist: [
+    "localModelUpdates",
+    "migrationDismissed",
+    "migrationJob",
+    "modelCollections",
+    "pollingEnabled",
+    "pollingMinutes",
+    "ready",
+    "startupSync"
+  ],
+  initialState: () => ({
+    autoPush: !0,
+    localModelUpdates: {},
+    migrationDismissed: !1,
+    migrationJob: null,
+    migrationPostponed: !1,
+    modelCollections: {},
+    pollingEnabled: !0,
+    pollingMinutes: 10,
+    ready: !1,
+    registeredModels: [],
+    schemaMigrations: /* @__PURE__ */ new Map(),
+    setupDismissed: !1,
+    setupOngoing: !1,
+    startupSync: !0,
+    status: b.Disconnected,
+    syncError: null,
+    syncJob: null
+  }),
+  serialize: (n) => {
+    var t;
+    return ke(n, { migrationJob: (t = n.migrationJob) == null ? void 0 : t.serialize() });
+  },
+  restore: (n) => ke(n, {
+    migrationJob: n.migrationJob && oe.restore(n.migrationJob)
+  }),
+  watch: {
+    migrationJob(n) {
+      n == null || n.listeners.add({ onUpdated: () => this.updatePersistedState("migrationJob") });
+    }
+  },
+  computed: {
+    disconnected: ({ status: n }) => n === b.Disconnected,
+    online: ({ status: n }) => n === b.Online,
+    syncing: ({ status: n }) => n === b.Syncing,
+    migrating: ({ status: n }) => n === b.Migrating,
+    localChanges({ localModelUpdates: n }) {
+      return Object.values(n).reduce((t, e) => t + e, 0);
+    },
+    dirty() {
+      return this.localChanges > 0;
+    },
+    migrationStarted({ migrationJob: n }) {
+      return !!n;
+    },
+    migrationDisabledReason({ status: n, ready: t }) {
+      return y.isLoggedIn() ? t ? n === b.Syncing || n === b.Migrating ? m(
+        "cloud.migrationNotSyncing",
+        "Wait for syncing to finish before starting the migration"
+      ) : this.online ? null : m(
+        "cloud.migrationNotOnline",
+        "You need to be online in order to start the migration"
+      ) : m(
+        "cloud.migrationNotReady",
+        "You need to backup your data before starting the migration"
+      ) : m(
+        "cloud.migrationNotLoggedIn",
+        "You need to reconnect before starting the migration"
+      );
+    }
+  }
+});
+class Fi extends Oi {
+  constructor() {
+    super(...arguments);
+    g(this, "asyncLock", new Ft());
+    g(this, "engine", null);
+    g(this, "pollingInterval", null);
+  }
+  async whenReady(e) {
+    return this.ready ? e() : new Promise((i) => {
+      const s = () => i(e());
+      d.once("cloud:ready", s);
+    });
+  }
+  async setup(e) {
+    this.setupOngoing = !0;
+    try {
+      await this.backup(e), await this.setReady(!0), await this.sync();
+    } finally {
+      this.setupOngoing = !1;
+    }
+  }
+  dismissSetup() {
+    this.setupDismissed = !0;
+  }
+  dismissMigration() {
+    this.migrationDismissed = !0;
+  }
+  postponeMigration() {
+    this.migrationPostponed = !0;
+  }
+  async syncIfOnline(e = {}) {
+    this.online && await this.sync(e);
+  }
+  async sync(e = {}) {
+    const i = _t(e) ? { models: e } : e instanceof F ? { model: e } : e;
+    !y.isLoggedIn() || !this.ready || !this.online || await this.asyncLock.run(async () => {
+      const s = Date.now(), o = i.model ? [i.model] : i.models;
+      this.syncError = null, this.status = b.Syncing, se.clear(o);
+      try {
+        if (await d.emit("cloud:sync-started", o), i.refreshUserProfile && await y.refreshUserProfile(), this.syncJob = new qi(o), this.syncJob.listeners.add(i), await ce(this.syncJob), this.syncJob.cancelled)
+          return;
+        S.testing || await T({ milliseconds: Math.max(500, 1e3 - (Date.now() - s)) }), this.syncJob = null;
+      } catch (r) {
+        if (S.testing)
+          throw r;
+        this.syncJob = null, this.syncError = r, await X.report(r, m("cloud.syncFailed", "Sync failed"));
+      } finally {
+        this.status = b.Online, await d.emit("cloud:sync-completed", o);
+      }
+    });
+  }
+  shouldMigrate() {
+    return this.schemaMigrations.size > 0;
+  }
+  async migrate(e) {
+    if (!this.online || !y.isLoggedIn() || !this.ready)
+      throw new Error("Data cannot be migrated at the moment");
+    this.shouldMigrate() && await this.asyncLock.run(async () => {
+      var r;
+      this.status = b.Migrating, this.migrationJob ?? (this.migrationJob = new oe());
+      const i = Date.now(), s = [], o = (r = this.migrationJob).models ?? (r.models = Ie());
+      se.clear(o);
+      try {
+        if (e && s.push(this.migrationJob.listeners.add(e)), await d.emit("cloud:migration-started", o), await ce(this.migrationJob), this.migrationJob.cancelled) {
+          await d.emit("cloud:migration-cancelled", o);
+          return;
+        }
+        this.migrationJob = null, this.migrationDismissed = !1, this.migrationPostponed = !1, await T({ milliseconds: Math.max(0, 1e3 - (Date.now() - i)) }), await d.emit("cloud:migration-completed", o);
+      } catch (a) {
+        await X.report(a, m("cloud.migrationFailed", "Migration failed"));
+      } finally {
+        this.status = b.Online, s.forEach((a) => a == null ? void 0 : a());
+      }
+    });
+  }
+  async register(e, i = {}) {
+    if (this.registeredModels.find((o) => e === o.modelClass))
+      return;
+    const s = this.engine;
+    s && _e(e).forEach((o) => x(o).setEngine(s)), this.whenReady(() => {
+      _(e) && (e.collection = pe(i.path));
+    }), await gi(e, {
+      created: (o) => We(o),
+      updated: (o) => Ne(o),
+      deleted: (o) => Ce([o])
+    }), _(e) && M(e).forEach((o) => {
+      const r = e.instance().requireRelation(o).relatedClass;
+      r.on("created", (a) => We(a)), r.on("updated", (a) => Ne(a)), r.on("deleted", (a) => Ce([a]));
+    }), this.registeredModels.push({ modelClass: e, path: i.path });
+    for (const o of this.modelCollections[e.modelName] ?? [])
+      await ie(e, o);
+  }
+  registerSchemaMigration(e, i) {
+    this.schemaMigrations.set(e, i);
+  }
+  requireRemoteCollection(e) {
+    for (const i of this.registeredModels)
+      if (e === i.modelClass)
+        return pe(i.path);
+    throw new Error(`Failed resolving remote collection for '${e.modelName}' model`);
+  }
+  async boot() {
+    await y.booted, y.isLoggedIn() && this.login(y.authenticator), d.on("auth:login", ({ authenticator: e }) => this.login(e)), d.on("auth:logout", () => this.logout()), d.once("application-ready", () => this.onApplicationReady()), d.once("application-mounted", () => this.onApplicationMounted()), Xe(() => {
+      if (this.pollingInterval && clearInterval(this.pollingInterval), !this.pollingEnabled || this.migrationJob) {
+        this.pollingInterval = null;
+        return;
+      }
+      this.pollingInterval = setInterval(() => this.sync(), this.pollingMinutes * 60 * 1e3);
+    });
+  }
+  getDirtyLocalModels() {
+    const e = Object.keys(this.localModelUpdates), i = [];
+    for (const { modelClass: s } of this.registeredModels)
+      for (const o of xe(s))
+        i.push(...this.getModelsIn(e, o));
+    return i;
+  }
+  getModelsIn(e, i) {
+    const s = [];
+    return e.includes(i.url) && s.push(i), P(i) && s.push(
+      ...tt(i).map((o) => this.getModelsIn(e, o)).flat()
+    ), s;
+  }
+  requireEngine() {
+    return this.engine ?? N("Could not get required Engine");
+  }
+  async setReady(e) {
+    this.ready || !e || (await d.emit("cloud:ready"), this.ready = !0);
+  }
+  async backup(e) {
+    await d.emit("cloud:backup-started"), e ?? (e = /* @__PURE__ */ new WeakMap());
+    const i = new Di();
+    for (const { modelClass: s, path: o } of this.registeredModels) {
+      if (!_(s))
+        continue;
+      for (const [l, c] of Object.entries(e.get(s) ?? {}))
+        i.migrateUrl(s, l, c);
+      const r = s.collection, a = pe(o);
+      s.collection = a, i.migrateCollection(s, r, a);
+    }
+    await ce(i), await d.emit("cloud:backup-completed");
+  }
+  async onApplicationReady() {
+    this.ready || !y.isLoggedIn() || await this.setReady(!Ie().some((e) => e.url.startsWith("solid://")));
+  }
+  async onApplicationMounted() {
+    this.syncOnStartup() && await this.sync();
+  }
+  login(e) {
+    const i = [...this.registeredModels].map(({ modelClass: s }) => _e(s)).flat().concat([W]);
+    this.status = b.Online, this.engine = e.engine;
+    for (const s of i)
+      x(s).setEngine(this.engine);
+  }
+  logout() {
+    this.setState({
+      localModelUpdates: {},
+      migrationDismissed: !1,
+      migrationJob: null,
+      migrationPostponed: !1,
+      modelCollections: {},
+      pollingEnabled: !0,
+      pollingMinutes: 10,
+      ready: !1,
+      setupDismissed: !1,
+      setupOngoing: !1,
+      startupSync: !0,
+      status: b.Disconnected
+    });
+  }
+  syncOnStartup() {
+    return j("startupSync") ? we(Q("startupSync")) : this.migrationJob ? !1 : this.startupSync;
+  }
+}
+const _i = ne(Fi), Wi = {
+  key: 1,
+  class: "flex flex-col gap-3"
+}, Yi = /* @__PURE__ */ Pe({
+  __name: "AGCloudStatus",
+  emits: ["sync"],
+  setup(n) {
+    return (t, e) => (D(), B(f(di), null, {
+      "logged-in": L(({ session: i }) => [
+        t.$cloud.syncing ? (D(), B(f(q), {
+          key: 0,
+          text: t.$td("cloud.syncing", "Syncing...")
+        }, null, 8, ["text"])) : (D(), te("div", Wi, [
+          R(f(q), {
+            text: t.$td("solid.loggedIn", "You are logged in as [{userName}]({userWebId})", {
+              userName: i.user.name ?? i.user.webId,
+              userWebId: i.user.webId
+            })
+          }, null, 8, ["text"]),
+          R(f(O), {
+            onClick: e[0] || (e[0] = (s) => (t.$cloud.sync(), t.$emit("sync")))
+          }, {
+            default: L(() => [
+              E($(t.$td("cloud.sync", "Synchronize")), 1)
+            ]),
+            _: 1
+          }),
+          R(f(O), {
+            onClick: e[1] || (e[1] = (s) => t.$solid.logout())
+          }, {
+            default: L(() => [
+              E($(t.$td("solid.logout", "Logout")), 1)
+            ]),
+            _: 1
+          })
+        ]))
+      ]),
+      _: 1
+    }));
+  }
+}), Ni = { $cloud: _i };
+function Qi() {
+  return {
+    name: "@aerogel/local-first",
+    async install(n) {
+      await Mt(n, {
+        ...Ni,
+        $_documentsCache: G
+      });
+    }
+  };
+}
+export {
+  Yi as AGCloudStatus,
+  _i as Cloud,
+  Fi as CloudService,
+  Qi as default
+};
+//# sourceMappingURL=aerogel-plugin-local-first.js.map