@aerogel/plugin-local-first 0.0.0-next.004d5deedf15bedf609a660bfd4543d3c0df9d9d

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

@@ -0,0 +1,1661 @@
+var Ze = Object.defineProperty;
+var Ge = (o, s, e) => s in o ? Ze(o, s, { enumerable: !0, configurable: !0, writable: !0, value: e }) : o[s] = e;
+var w = (o, s, e) => Ge(o, typeof s != "symbol" ? s + "" : s, e);
+import { Service as Xe, appNamespace as et, Events as D, App as se, Job as ye, Errors as Z, defineServiceState as tt, replaceExisting as ve, translateWithDefault as $, dispatch as re, Modal as ze, Markdown as T, Link as ue, Button as q, UI as ae, Storage as nt, defineSettings as st, useEvent as ot, SettingsModal as Ee, ProgressBar as it, AdvancedOptions as rt, Checkbox as le, EditableContent as at, DropdownMenu as lt, bootServices as ct } from "@aerogel/core";
+import { facade as we, IndexedDBMap as dt, arrayFilter as ut, isInstanceOf as E, after as G, arrayRemove as ht, required as A, tap as Te, urlRoute as qe, urlResolveDirectory as ft, objectWithout as mt, requireUrlParentDirectory as X, fail as Pe, arrayFrom as gt, map as L, arrayChunk as pt, mixed as Oe, objectMap as yt, round as wt, toString as Mt, Semaphore as bt, isArray as Ct, isTesting as $e, hasLocationQueryParameter as Se, parseBoolean as De, getLocationQueryParameter as ke } from "@noeldemartin/utils";
+import { Solid as C, SolidLogin as vt, SolidAvatar as _e } from "@aerogel/plugin-solid";
+import { SolidModel as N, SolidContainsRelation as xe, isContainerClass as x, SolidContainer as j, SolidACLAuthorization as $t, SolidDocument as St, Metadata as Dt, Operation as kt, isContainer as U, Tombstone as W, PropertyOperation as ee, isSolidModel as Rt } from "soukai-solid";
+import { getTrackedModels as Me, trackModelsCollection as te, ignoreModelsCollection as Lt, trackModels as Ut } from "@aerogel/plugin-soukai";
+import { watchEffect as At, markRaw as O, createElementBlock as M, openBlock as h, createElementVNode as f, defineComponent as B, createBlock as R, unref as d, withCtx as b, createVNode as u, createTextVNode as K, toDisplayString as S, createCommentVNode as _, useTemplateRef as It, ref as zt, computed as Y, normalizeClass as Et } from "vue";
+import { bootModels as Tt, requireEngine as qt, DocumentNotFound as Pt, InvalidModelAttributes as Ot, requireBootedModel as _t, getBootedModels as xt } from "soukai";
+import { MalformedSolidDocumentError as Jt } from "@noeldemartin/solid-utils";
+class Nt extends Xe {
+  constructor() {
+    super(...arguments);
+    w(this, "cache", new dt(`${et()}-documents-cache`));
+  }
+  async isFresh(e, t) {
+    const n = await this.cache.get(e), i = typeof t != "number" ? t.getTime() : t;
+    return !!(n != null && n.modifiedAt) && n.modifiedAt >= i;
+  }
+  async remember(e, t) {
+    await this.cache.set(e, {
+      modifiedAt: typeof t != "number" ? t.getTime() : t
+    });
+  }
+  async forget(e) {
+    await this.cache.delete(e);
+  }
+  async clear() {
+    await this.cache.clear();
+  }
+  async boot() {
+    D.on("auth:logout", async () => {
+      await this.cache.clear(), this.cache.close();
+    });
+  }
+}
+const P = we(Nt), ce = /* @__PURE__ */ new WeakMap();
+function he(o) {
+  return ut(
+    k(o).map((s) => {
+      const e = o.instance().requireRelation(s).relatedClass;
+      return x(e) ? !1 : e;
+    })
+  );
+}
+function k(o) {
+  return ce.has(o) || ce.set(
+    o,
+    o.relations.filter((s) => N.reservedRelations.includes(s) ? !1 : o.instance().requireRelation(s) instanceof xe)
+  ), ce.get(o) ?? [];
+}
+function Je(o) {
+  return k(o.static()).reduce(
+    (e, t) => e.concat(o.getRelationModels(t) ?? []),
+    []
+  );
+}
+function Re(o) {
+  const s = /* @__PURE__ */ new Set(), e = o.instance();
+  s.add(o);
+  for (const t of o.relations)
+    o.reservedRelations.includes(t) || s.add(e.requireRelation(t).relatedClass);
+  return [...s.values()];
+}
+function fe(o) {
+  return o.getRelatedModels().filter(
+    (s) => !E(s, $t) && !E(s, St) && !E(s, Dt) && !E(s, kt) && s.static() !== j
+  );
+}
+function Ne(o) {
+  if (o.isDirty())
+    return !0;
+  if (!(o instanceof j))
+    return !1;
+  const s = (e) => {
+    var t;
+    return (t = o.getRelationModels(e)) == null ? void 0 : t.some((n) => Ne(n));
+  };
+  return k(o.static()).some(s);
+}
+const Wt = A(() => se.service("$cloud"));
+class jt {
+  constructor() {
+    w(this, "models", /* @__PURE__ */ new Set());
+    w(this, "promises", []);
+  }
+  push(s) {
+    this.models.add(s), this.syncAfter(G({ seconds: 1 }));
+  }
+  clear(s) {
+    if (!s) {
+      this.models = /* @__PURE__ */ new Set();
+      return;
+    }
+    for (const e of s)
+      this.models.delete(e);
+  }
+  async syncAfter(s) {
+    const e = typeof s == "function" ? s() : s;
+    return this.promises.push(e), e.then(() => ht(this.promises, e)), this.promises.length === 1 && this.schedule(), e;
+  }
+  schedule() {
+    Promise.all(this.promises).then(() => G()).then(() => {
+      if (this.promises.length !== 0) {
+        this.schedule();
+        return;
+      }
+      const s = this.consume();
+      s.length !== 0 && Wt.syncIfOnline(s);
+    });
+  }
+  consume() {
+    const s = [], e = /* @__PURE__ */ new Set();
+    for (const t of this.models)
+      U(t) && (this.models.delete(t), Je(t).forEach((n) => e.add(n)), s.push(t));
+    for (const t of this.models)
+      this.models.delete(t), !e.has(t) && s.push(t);
+    return s;
+  }
+}
+const ne = we(jt), y = A(() => se.service("$cloud")), We = /* @__PURE__ */ new WeakMap(), be = /* @__PURE__ */ new WeakMap();
+function Bt(o) {
+  const s = o.getRelatedModels().concat([o]);
+  for (const e of s)
+    e.cleanDirty(!0);
+}
+function Vt(o) {
+  const s = fe(o).concat([o]);
+  for (const e of s) {
+    if (!e.operations || e.operations.length === 0)
+      continue;
+    const t = (e.operations ?? []).filter((n) => !(n instanceof ee) || !e.ignoreRdfPropertyHistory(n.property, !0));
+    if (!t.some((n) => !n.isInception(e))) {
+      e.setRelationModels("operations", []);
+      continue;
+    }
+    e.setRelationModels("operations", t);
+  }
+}
+async function Le(o) {
+  y.setState({
+    localModelUpdates: {
+      ...y.localModelUpdates,
+      [o.url]: 1
+    }
+  }), Xt(o.static()) && await me(o.static(), X(o.url)), y.autoPush && y.ready && !y.syncing && ne.push(o);
+}
+async function me(o, s) {
+  var e, t;
+  (e = y.modelCollections[o.modelName]) != null && e.includes(s) || (y.setState("modelCollections", {
+    ...y.modelCollections,
+    [o.modelName]: (y.modelCollections[o.modelName] ?? []).concat(s)
+  }), (t = y.modelCollections[o.modelName]) != null && t.includes(o.collection) || (o.collection = s), await te(o, s));
+}
+async function Ue(o) {
+  if (Ft(o))
+    return;
+  const s = y.localModelUpdates[o.url] ?? 0;
+  y.setState({
+    localModelUpdates: o.isSoftDeleted() ? mt(y.localModelUpdates, o.url) : {
+      ...y.localModelUpdates,
+      [o.url]: s + 1
+    }
+  }), await P.forget(o.requireDocumentUrl()), y.autoPush && y.ready && !y.syncing && ne.push(o);
+}
+function ge(o, s) {
+  const e = {}, t = Array.from(o);
+  for (const [n, i] of Object.entries(y.localModelUpdates)) {
+    const l = qe(n);
+    (o.has(n) || t.some((r) => r.endsWith("/") && n.startsWith(r))) && !(s != null && s.has(l)) || (e[n] = i);
+  }
+  y.setState({ localModelUpdates: e });
+}
+function Ce(o, s = {}) {
+  const e = /* @__PURE__ */ new Set();
+  if (e.add(o.static()), o instanceof j)
+    for (const n of k(o.static()))
+      e.add(o.requireRelation(n).relatedClass);
+  const t = [...e.values()].map(
+    (n) => [n, z(n)]
+  );
+  return Te(o.clone({ constructors: t }), (n) => {
+    Vt(n), s.clean && Bt(n);
+  });
+}
+function je(o) {
+  const s = /* @__PURE__ */ new Set();
+  if (s.add(o.static()), o instanceof j)
+    for (const t of k(o.static()))
+      s.add(o.requireRelation(t).relatedClass);
+  const e = [...s.values()].map(
+    (t) => [t, tn(t)]
+  );
+  return o.clone({ constructors: e });
+}
+async function Ae(o, s, e) {
+  const t = z(W), n = s.map((a) => a.url), i = o.filter((a) => !n.includes(a.url)).map((a) => a.requireDocumentUrl()).filter((a) => !e.has(a)), l = await t.all({ $in: i });
+  return s.concat(l);
+}
+function Ft(o) {
+  const s = o.getDocumentModels(), e = s.flatMap(
+    (n) => {
+      var i;
+      return ((i = n.operations) == null ? void 0 : i.map((l) => [n, l])) ?? [];
+    }
+  ), t = Math.max(...s.map((n) => {
+    var i, l;
+    return ((l = (i = n.metadata) == null ? void 0 : i.updatedAt) == null ? void 0 : l.getTime()) ?? 0;
+  }));
+  return !e.some(([n, i]) => i.date.getTime() !== t ? !1 : i instanceof ee ? !n.ignoreRdfPropertyHistory(i.property, !0) : !0);
+}
+function Ht(o, s) {
+  return s.get(o.url) ?? je(o);
+}
+function pe() {
+  return [...y.registeredModels].map(({ modelClass: o }) => Me(o, { includeSoftDeleted: !0 })).flat();
+}
+function Kt() {
+  return y.schemaMigrations;
+}
+function Yt() {
+  y.schemaMigrations.clear();
+}
+function Ie(o) {
+  return y.schemaMigrations.get(o);
+}
+function z(o) {
+  return We.get(o) ?? en(o);
+}
+function de(o, s) {
+  const e = C.requireUser().storageUrls[0], t = x(o) && k(o).map((n) => {
+    const i = o.instance().requireRelation(n).relatedClass;
+    return x(i) ? null : i;
+  }).filter(Boolean)[0];
+  return s ?? (s = `/${(t || o).modelName.toLowerCase()}s/`), ft((s.startsWith("/") ? e.slice(0, -1) : e) + s);
+}
+function Qt(o, s) {
+  return s.get(o.url) ?? Ce(o);
+}
+function Zt(o) {
+  for (const { modelClass: s } of y.registeredModels)
+    if (Me(s).some((t) => t.url === o.url))
+      return !0;
+  return !1;
+}
+function Q(o) {
+  return be.has(o.static());
+}
+function Gt(o) {
+  return !Q(o);
+}
+function Xt(o) {
+  return y.registeredModels.some(({ modelClass: s }) => s === o);
+}
+function en(o) {
+  var n;
+  const s = o, e = (i, l) => {
+    i.timestamps = s.timestamps, i.history = s.history, l(), i.timestamps = [], i.history = !1;
+  }, t = (n = class extends s {
+    initialize(i, l) {
+      e(this._proxy.static(), () => super.initialize(i, l));
+    }
+    initializeRelations() {
+      super.initializeRelations();
+      for (const i of Object.values(this._relations))
+        i instanceof xe && (i.relatedClass = z(i.relatedClass));
+    }
+    fixMalformedAttributes() {
+      e(this.static(), () => super.fixMalformedAttributes());
+    }
+  }, w(n, "timestamps", !1), w(n, "history", !1), n);
+  return We.set(s, t), be.set(t, s), s.on("schema-updated", async (i) => {
+    await t.updateSchema({
+      ...i,
+      timestamps: !1,
+      history: !1
+    });
+  }), Tt({ [`Remote${o.modelName}`]: t }), t;
+}
+function tn(o) {
+  return be.get(o) ?? Pe(`Couldn't find local class for ${o.modelName}`);
+}
+class nn extends ye {
+  constructor() {
+    super(...arguments);
+    w(this, "urlMigrations", []);
+    w(this, "collectionMigrations", []);
+  }
+  migrateUrl(e, t, n) {
+    this.urlMigrations.push({
+      modelClass: e,
+      local: t,
+      remote: n
+    });
+  }
+  migrateCollection(e, t, n) {
+    this.collectionMigrations.push({
+      modelClass: e,
+      local: t,
+      remote: n
+    });
+  }
+  async run() {
+    const e = qt(), t = await e.getCollections();
+    for (const n of t) {
+      const i = await e.readMany(n);
+      for (const [l, a] of Object.entries(i)) {
+        const r = this.replaceUrl(l);
+        await e.create(X(r), this.replaceDocumentUrls(a), r), await e.delete(n, l);
+      }
+    }
+    for (const { modelClass: n, remote: i } of this.urlMigrations)
+      te(n, X(i), { refresh: !1 });
+    for (const { modelClass: n, local: i, remote: l } of this.collectionMigrations)
+      Lt(n, i), te(n, l, { refresh: !1 });
+  }
+  replaceDocumentUrls(e) {
+    for (const [t, n] of Object.entries(e)) {
+      if (t === "@id" && typeof n == "string") {
+        e[t] = this.replaceUrl(n);
+        continue;
+      }
+      typeof n != "object" || n === null || (e[t] = this.replaceDocumentUrls(n));
+    }
+    return e;
+  }
+  replaceUrl(e) {
+    for (const { local: t, remote: n } of this.urlMigrations)
+      if (e.startsWith(t))
+        return e.replace(t, n);
+    for (const { local: t, remote: n } of this.collectionMigrations)
+      if (e.startsWith(t))
+        return e.replace(t, n);
+    return e;
+  }
+}
+function sn(o) {
+  const s = {};
+  return async () => ("value" in s || (s.value = await o()), s.value);
+}
+class Be {
+  async loadContainedModels(s, e = {}) {
+    var p;
+    if (Gt(s)) {
+      const m = [];
+      for (const g of k(s.static())) {
+        const J = await s.loadRelationIfUnloaded(g) ?? [];
+        m.push(...gt(J));
+      }
+      return m;
+    }
+    const t = {}, n = [], i = L(s.documents, "url"), l = pt(s.resourceUrls, 10), a = l.flat().map((m) => ({
+      documentUrl: m,
+      completed: !1
+    })), r = L(a, "documentUrl");
+    e.status && (e.status.children = a);
+    for (const m of l) {
+      await Promise.all(
+        m.map(async (g) => {
+          const { children: J, tombstones: Ye } = await this.loadDocumentChildren(
+            s,
+            g,
+            i,
+            e.onDocumentError,
+            e.onDocumentRead
+          );
+          n.push(...Ye);
+          for (const [ie, Qe] of Object.entries(J))
+            (t[ie] ?? (t[ie] = [])).push(...Qe);
+        })
+      );
+      for (const g of m)
+        g.endsWith("/") || (A(r.get(g)).completed = !0);
+      await ((p = e.onDocumentsLoaded) == null ? void 0 : p.call(e, m));
+    }
+    for (const [m, g] of Object.entries(t))
+      s.setRelationModels(m, g);
+    const c = e.ignoreTombstones ? Object.values(t).flat() : Object.values(t).flat().concat(n);
+    return e.status && (e.status.children = c.map((m) => A(r.get(m.requireDocumentUrl())))), c;
+  }
+  async loadDocumentChildren(s, e, t, n, i) {
+    var a;
+    const l = t.get(e);
+    return l && l.updatedAt && await P.isFresh(l.url, l.updatedAt) && ((a = this.localModels) != null && a.hasKey(s.url)) ? {
+      children: await this.loadDocumentChildrenFromLocal(s, l),
+      tombstones: []
+    } : this.loadDocumentChildrenFromRemote(s, e, n, i);
+  }
+  async loadDocumentChildrenFromLocal(s, e) {
+    var n, i;
+    const t = {};
+    for (const l of k(s.static())) {
+      const a = s.requireRelation(l);
+      if (a.loaded) {
+        t[l] = a.getLoadedModels();
+        continue;
+      }
+      const r = ((i = (n = this.localModels) == null ? void 0 : n.get(s.url)) == null ? void 0 : i.getRelationModels(l)) ?? [];
+      t[l] = r.filter((c) => c.getDocumentUrl() === e.url).map((c) => Ce(c, { clean: !0 }));
+    }
+    return t;
+  }
+  async loadDocumentChildrenFromRemote(s, e, t, n) {
+    const i = {}, l = [], a = sn(async () => {
+      try {
+        const r = s.documents.find((m) => m.url === e), c = await s.requireEngine().readOne(s.static("collection"), e), p = await W.createManyFromEngineDocuments({
+          [e]: c
+        });
+        return l.push(...p), r && (n == null || n(r)), c;
+      } catch (r) {
+        if (E(r, Pt))
+          return null;
+        if (!t)
+          throw r;
+        return t(r), null;
+      }
+    });
+    for (const r of k(s.static())) {
+      const c = s.requireRelation(r);
+      if (c.loaded) {
+        i[r] = c.getLoadedModels();
+        continue;
+      }
+      const p = await a();
+      if (p)
+        try {
+          const m = await c.relatedClass.createManyFromEngineDocuments({
+            [e]: p
+          });
+          i[r] = m;
+        } catch (m) {
+          if (!t)
+            throw m;
+          t(m);
+        }
+    }
+    return { children: i, tombstones: l };
+  }
+}
+const V = /* @__PURE__ */ new WeakMap();
+class Ve {
+  async loadTypeIndex(s = {}) {
+    const e = C.requireUser();
+    return (s.fresh || !V.has(e)) && V.set(e, await C.findPrivateTypeIndex({ fresh: s.fresh })), s.create && !V.get(e) && V.set(e, await C.findOrCreatePrivateTypeIndex()), V.get(e) ?? null;
+  }
+}
+class Fe {
+  async indexLocalModels(s) {
+    for (const e of s)
+      await this.addLocalModel(e);
+  }
+  async addLocalModel(s) {
+    if (!this.localModels.hasKey(s.url)) {
+      this.localModels.add(s);
+      for (const e of k(s.static()))
+        await s.loadRelationIfUnloaded(e);
+      for (const e of s.getRelatedModels())
+        this.localModels.add(e);
+    }
+  }
+}
+const on = ye;
+class oe extends Oe(on, [Be, Ve, Fe]) {
+  constructor() {
+    super();
+    w(this, "_models");
+    this.localModels = L([], "url");
+  }
+  static restore(e) {
+    return Te(new oe(), (t) => {
+      t.status = e;
+    });
+  }
+  get models() {
+    return this._models;
+  }
+  set models(e) {
+    if (!e) {
+      delete this._models, this.localModels = L([], "url");
+      return;
+    }
+    const t = yt(this.status.children ?? [], "modelUrl");
+    this._models = e, this.localModels = L([], "url"), this.status.children = e.map(
+      (n) => t[n.url] ?? {
+        modelUrl: n.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 ?? [], t = await this.loadTypeIndex();
+    for (const n of e) {
+      const i = this.models.find(({ url: l }) => n.modelUrl === l);
+      !i || n.completed || (await this.migrateRegisteredModel(i, n, t), await this.updateProgress(() => n.completed = !0));
+    }
+    for (const [n, i] of Kt())
+      await n.updateSchema(i);
+    Yt();
+  }
+  async migrateRegisteredModel(e, t, n) {
+    if (await this.migrate(e, t), !U(e))
+      return;
+    const i = he(e.static()), l = n == null ? void 0 : n.registrations.find(({ instanceContainer: a }) => a === e.url);
+    !n || !l || i.length === 0 || (l.setAttribute(
+      "forClass",
+      i.map((a) => {
+        var r;
+        return ((r = Ie(a)) == null ? void 0 : r.rdfsClasses) ?? a.rdfsClass;
+      }).flat()
+    ), await n.save());
+  }
+  async migrate(e, t) {
+    this.assertNotCancelled(), await this.migrateChildren(e, t);
+    const n = Ie(e.static());
+    if (!n)
+      return;
+    const i = await z(e.static()).find(e.url), l = await (i == null ? void 0 : i.migrateSchema(n));
+    await e.migrateSchema(n, {
+      mintOperationUrl: (a) => {
+        var r, c;
+        return (c = (r = l == null ? void 0 : l.operations) == null ? void 0 : r.find((p) => !E(a, ee) || !E(p, ee) ? !1 : a.property === p.property && a.date.getTime() === p.date.getTime())) == null ? void 0 : c.url;
+      }
+    });
+  }
+  async migrateChildren(e, t) {
+    if (!U(e))
+      return;
+    const n = await this.loadContainedModels(e, { ignoreTombstones: !0 });
+    t.children ?? (t.children = n.map((i) => ({
+      modelUrl: i.url,
+      completed: !1
+    })));
+    for (const i of t.children) {
+      const l = n.find(({ url: a }) => i.modelUrl === a);
+      !l || i.completed || (await this.migrate(l, i), await this.updateProgress(() => i.completed = !0));
+    }
+  }
+}
+const rn = A(() => se.service("$cloud")), an = ye;
+function ln(o) {
+  return !!o && "root" in o;
+}
+class cn extends Oe(an, [Be, Ve, Fe]) {
+  constructor(e) {
+    super();
+    w(this, "models");
+    w(this, "dirtyRemoteModels");
+    w(this, "rootLocalModels");
+    w(this, "tombstones");
+    w(this, "documentsWithErrors");
+    w(this, "syncedModelUrls");
+    w(this, "documentsModifiedAt");
+    w(this, "screenLock", null);
+    w(this, "localModels");
+    this.models = e, this.rootLocalModels = [], this.localModels = L([], "url"), this.tombstones = L([], "resourceUrl"), this.documentsWithErrors = /* @__PURE__ */ new Set(), this.syncedModelUrls = /* @__PURE__ */ new Set(), this.documentsModifiedAt = {};
+  }
+  async run() {
+    const e = C.requireAuthenticator().engine, t = (i, { headers: l }, a) => {
+      const r = (l == null ? void 0 : l.get("last-modified")) ?? a;
+      !r || i.endsWith("/") || (this.documentsModifiedAt[i] = new Date(r));
+    }, n = e.listeners.add({
+      onDocumentRead: (i, l) => t(i, l),
+      onDocumentUpdated: (i, l) => t(i, l, /* @__PURE__ */ new Date())
+    });
+    try {
+      this.lockScreen(), this.rootLocalModels = this.models ?? pe(), await this.indexLocalModels(this.rootLocalModels), await this.pullChanges(), await this.pushChanges();
+    } finally {
+      this.releaseScreen(), n();
+    }
+  }
+  lockScreen() {
+    const e = navigator;
+    if (e.wakeLock)
+      try {
+        this.screenLock = e.wakeLock.request("screen").catch((t) => {
+          Z.reportDevelopmentError(t, "Could not request screen wake lock");
+        });
+      } catch (t) {
+        Z.reportDevelopmentError(t, "Could not request screen wake lock");
+      }
+  }
+  releaseScreen() {
+    this.screenLock && (this.screenLock.then((e) => e == null ? void 0 : e.release()), this.screenLock = null);
+  }
+  getInitialStatus() {
+    return {
+      root: !0,
+      completed: !1,
+      children: [{ completed: !1 }, { completed: !1 }]
+    };
+  }
+  calculateCurrentProgress(e) {
+    return e ?? (e = this.status), ln(e) ? wt(
+      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(), t = L(e, (n) => n instanceof W ? n.resourceUrl : n.url);
+    this.dirtyRemoteModels = await this.synchronizeModels(t), await this.updateProgress((n) => n.children[0].completed = !0);
+  }
+  async pushChanges() {
+    const e = this.dirtyRemoteModels ?? [], t = this.status.children[1].children = e.map(() => ({ completed: !1 }));
+    for (let n = 0; n < e.length; n++) {
+      const i = e[n], l = t[n];
+      if (i.isSoftDeleted()) {
+        i.enableHistory(), i.enableTombstone(), await i.forceDelete(), await this.updateProgress(() => l.completed = !0);
+        return;
+      }
+      await this.saveModelAndChildren(i, l), await this.updateTypeRegistrations(i), await this.updateProgress(() => l.completed = !0);
+    }
+    for (const [n, i] of Object.entries(this.documentsModifiedAt))
+      await P.remember(n, i);
+    ge(this.syncedModelUrls, this.documentsWithErrors), await this.updateProgress((n) => n.children[1].completed = !0);
+  }
+  async fetchRemoteModels() {
+    const e = this.status.children[0], t = await this.loadTypeIndex({ fresh: !0 });
+    if (!t)
+      return [];
+    const n = [], i = this.getTypeRegistrations(t);
+    e.children = i.map(() => ({ completed: !1 }));
+    for (let l = 0; l < i.length; l++)
+      await this.ignoringDocumentErrors(async () => {
+        var p;
+        const { registration: a, registeredModel: r } = A(i[l]), c = z(r.modelClass);
+        if (a.instanceContainer) {
+          if (x(c)) {
+            await me(
+              r.modelClass,
+              X(a.instanceContainer)
+            );
+            const m = await c.find(a.instanceContainer);
+            m && (await this.loadChildren(m, A((p = e.children) == null ? void 0 : p[l])), n.push(m)), await this.updateProgress(() => {
+              var g;
+              return A((g = e.children) == null ? void 0 : g[l]).completed = !0;
+            });
+            return;
+          }
+          await me(r.modelClass, a.instanceContainer), n.push(...await c.from(a.instanceContainer).all()), await this.updateProgress(() => {
+            var m;
+            return A((m = e.children) == null ? void 0 : m[l]).completed = !0;
+          });
+        }
+      });
+    return Ae(this.rootLocalModels, n, this.documentsWithErrors);
+  }
+  async fetchRemoteModelsForLocal(e) {
+    const t = [], n = this.status.children[0].children = e.map(() => ({ completed: !1 }));
+    for (let i = 0; i < e.length; i++)
+      await this.ignoringDocumentErrors(async () => {
+        const l = e[i], a = n[i], r = await z(l.static()).find(l.url);
+        if (!r) {
+          await this.updateProgress(() => a.completed = !0);
+          return;
+        }
+        U(r) && await this.loadChildren(r, a), t.push(r), await this.updateProgress(() => a.completed = !0);
+      });
+    return Ae(e, t, this.documentsWithErrors);
+  }
+  getTypeRegistrations(e) {
+    const t = /* @__PURE__ */ new Set(), n = [...rn.registeredModels].map(({ modelClass: a }) => {
+      const r = x(a) ? he(a) : [];
+      return {
+        modelClass: a,
+        rdfsClasses: r.length > 0 ? r.map((c) => c.rdfsClasses).flat() : a.rdfsClasses
+      };
+    }), i = e.registrations.map((a) => {
+      const r = n.find(
+        ({ rdfsClasses: c }) => !!a.instanceContainer && c.some((p) => a.forClass.includes(p))
+      );
+      return !r || !a.instanceContainer || t.has(a.instanceContainer) ? null : (t.add(a.instanceContainer), { registration: a, registeredModel: r });
+    }).filter((a) => !!a), l = i.map(({ registration: a }) => a.instanceContainer);
+    return i.filter(({ registration: a }) => !l.some(
+      (r) => {
+        var c;
+        return r && r !== a.instanceContainer && ((c = a.instanceContainer) == null ? void 0 : c.startsWith(r));
+      }
+    ));
+  }
+  async updateTypeRegistrations(e) {
+    if (!Zt(e))
+      return;
+    const t = U(e) ? he(e.static()) : [e.static()], n = z(j), i = U(e) ? e : new n({ url: e.requireContainerUrl() });
+    if (t.length === 0)
+      return;
+    const l = await this.loadTypeIndex({ create: !0 });
+    l.registrations.some((a) => a.instanceContainer === e.url) || await i.register(l, t);
+  }
+  async loadChildren(e, t) {
+    var i, l;
+    if (this.assertNotCancelled(), !U(e))
+      return;
+    const n = await this.loadContainedModels(e, {
+      status: t,
+      onDocumentError: (a) => this.handleDocumentError(a),
+      onDocumentRead: (a) => {
+        a.url.endsWith("/") || !a.updatedAt || a.url in this.documentsModifiedAt || (this.documentsModifiedAt[a.url] = a.updatedAt);
+      },
+      onDocumentsLoaded: async () => {
+        this.assertNotCancelled(), await this.updateProgress();
+      }
+    });
+    for (let a = 0; a < n.length; a++) {
+      const r = n[a];
+      if (r instanceof W) {
+        this.tombstones.add(r);
+        continue;
+      }
+      if (this.tombstones.hasKey(r.url)) {
+        await this.deleteChild(e, r);
+        continue;
+      }
+      await this.loadChildren(r, (i = t == null ? void 0 : t.children) == null ? void 0 : i[a]), (l = t == null ? void 0 : t.children) != null && l[a] && await this.updateProgress(() => {
+        var c;
+        return A((c = t.children) == null ? void 0 : c[a]).completed = !0;
+      });
+    }
+  }
+  async deleteChild(e, t) {
+    for (const n of e.static("relations")) {
+      const i = e.requireRelation(n);
+      if (i.related) {
+        if (Array.isArray(i.related)) {
+          i.related = i.related.filter((l) => l !== t);
+          continue;
+        }
+        if (i.related === t) {
+          i.related = null;
+          continue;
+        }
+      }
+    }
+    await t.forceDelete();
+  }
+  async saveModelAndChildren(e, t) {
+    if (this.assertNotCancelled(), Q(e) && e.isSoftDeleted()) {
+      e.enableHistory(), e.enableTombstone(), await e.forceDelete();
+      return;
+    }
+    if (this.documentsWithErrors.has(e.requireDocumentUrl()))
+      return;
+    const n = e.isDirty();
+    if (await e.save(), (n || Q(e)) && this.syncedModelUrls.add(e.url), !U(e)) {
+      if (Q(e)) {
+        const a = e.requireDocumentUrl(), r = this.documentsModifiedAt[a];
+        r && (await P.remember(a, r), delete this.documentsModifiedAt[a]);
+      }
+      return;
+    }
+    const i = k(e.static()).map((a) => e.getRelationModels(a) ?? []).flat(), l = t ? i.map(() => ({ completed: !1 })) : [];
+    t && (t.children = l);
+    for (let a = 0; a < i.length; a++) {
+      const r = i[a], c = l[a];
+      await this.saveModelAndChildren(r, c), c && await this.updateProgress(() => c.completed = !0);
+    }
+  }
+  async synchronizeModels(e) {
+    const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+    for (const l of e.items()) {
+      if (l instanceof W) {
+        const r = this.localModels.get(l.resourceUrl);
+        r && (await r.forceDelete(), n.add(r));
+        continue;
+      }
+      const a = Ht(l, this.localModels);
+      a.exists() || this.syncedModelUrls.add(a.url), await this.loadChildren(a), await N.synchronize(a, l), await this.reconcileInconsistencies(a, l), await this.saveModelAndChildren(a), await this.addLocalModel(a), this.rootLocalModels.push(a), t.add(a.url);
+    }
+    for (const l of this.rootLocalModels) {
+      if (n.has(l) || t.has(l.url))
+        continue;
+      await this.loadChildren(l);
+      const a = Qt(l, e);
+      await N.synchronize(l, a), e.add(a);
+    }
+    const i = [];
+    for (const l of e.getItems()) {
+      if (Ne(l)) {
+        i.push(l);
+        continue;
+      }
+      await this.rememberModelDocuments(l);
+    }
+    return i;
+  }
+  async reconcileInconsistencies(e, t, n) {
+    e.rebuildAttributesFromHistory(), e.setAttributes(t.getAttributes(!0)), n ?? (n = /* @__PURE__ */ new Set()), n.add(e);
+    for (const l of k(e.static()))
+      await this.synchronizeContainerDocuments(
+        e.requireRelation(l),
+        t.requireRelation(l)
+      );
+    const i = L(fe(t), "url");
+    for (const l of fe(e))
+      n.has(l) || !l.isRelationLoaded("operations") || !i.hasKey(l.url) || await this.reconcileInconsistencies(
+        l,
+        i.require(l.url),
+        n
+      );
+    e.isDirty() && await N.synchronize(e, t);
+  }
+  async synchronizeContainerDocuments(e, t) {
+    const n = L(e.related ?? [], "url"), i = L(t.related ?? [], "url"), l = n.getKeys().filter((r) => !i.hasKey(r) && !i.hasKey(encodeURI(r))), a = i.getKeys().filter((r) => !n.hasKey(r) && !n.hasKey(encodeURI(r)));
+    for (const r of l) {
+      const c = n.require(r), p = Ce(c);
+      t.addRelated(p), i.add(p);
+    }
+    for (const r of a) {
+      const c = i.require(r), p = je(c);
+      e.addRelated(p), n.add(p), this.syncedModelUrls.add(p.url);
+    }
+    for (const r of n.items()) {
+      const c = i.require(r.url);
+      await N.synchronize(r, c), await this.saveModelAndChildren(r);
+    }
+  }
+  async rememberModelDocuments(e) {
+    if (!U(e)) {
+      const n = e.requireDocumentUrl(), i = this.documentsModifiedAt[n];
+      i && (await P.remember(n, i), delete this.documentsModifiedAt[n]);
+      return;
+    }
+    const t = k(e.static()).map((n) => e.getRelationModels(n) ?? []).flat();
+    for (const n of t)
+      await this.rememberModelDocuments(n);
+  }
+  async ignoringDocumentErrors(e) {
+    try {
+      await e();
+    } catch (t) {
+      this.handleDocumentError(t);
+    }
+  }
+  handleDocumentError(e) {
+    if (E(e, Jt)) {
+      console.warn(e.message), e.documentUrl && this.documentsWithErrors.add(e.documentUrl);
+      return;
+    }
+    if (E(e, Ot)) {
+      console.warn(e.message);
+      const t = e.attributes[_t(e.modelName).primaryKey], n = t && qe(Mt(t));
+      n && this.documentsWithErrors.add(n);
+      return;
+    }
+    throw e;
+  }
+}
+const v = {
+  Disconnected: "disconnected",
+  Online: "online",
+  Syncing: "syncing",
+  Migrating: "migrating"
+}, dn = tt({
+  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: v.Disconnected,
+    syncError: null,
+    syncJob: null
+  }),
+  serialize: (o) => {
+    var s;
+    return ve(o, { migrationJob: (s = o.migrationJob) == null ? void 0 : s.serialize() });
+  },
+  restore: (o) => ve(o, {
+    migrationJob: o.migrationJob && oe.restore(o.migrationJob)
+  }),
+  watch: {
+    migrationJob(o) {
+      o == null || o.listeners.add({ onUpdated: () => this.updatePersistedState("migrationJob") });
+    }
+  },
+  computed: {
+    disconnected: ({ status: o }) => o === v.Disconnected,
+    online: ({ status: o }) => o === v.Online,
+    syncing: ({ status: o }) => o === v.Syncing,
+    migrating: ({ status: o }) => o === v.Migrating,
+    localChanges({ localModelUpdates: o }) {
+      return Object.values(o).reduce((s, e) => s + e, 0);
+    },
+    dirty() {
+      return this.localChanges > 0;
+    },
+    migrationStarted({ migrationJob: o }) {
+      return !!o;
+    },
+    migrationDisabledReason({ status: o, ready: s }) {
+      return C.isLoggedIn() ? s ? o === v.Syncing || o === v.Migrating ? $(
+        "cloud.migrationNotSyncing",
+        "Wait for syncing to finish before starting the migration"
+      ) : this.online ? null : $(
+        "cloud.migrationNotOnline",
+        "You need to be online in order to start the migration"
+      ) : $(
+        "cloud.migrationNotReady",
+        "You need to backup your data before starting the migration"
+      ) : $(
+        "cloud.migrationNotLoggedIn",
+        "You need to reconnect before starting the migration"
+      );
+    }
+  }
+});
+class un extends dn {
+  constructor() {
+    super(...arguments);
+    w(this, "asyncLock", new bt());
+    w(this, "engine", null);
+    w(this, "pollingInterval", null);
+  }
+  async whenReady(e) {
+    return this.ready ? e() : new Promise((t) => {
+      const n = () => t(e());
+      D.once("cloud:ready", n);
+    });
+  }
+  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 t = Ct(e) ? { models: e } : e instanceof N ? { model: e } : e;
+    !C.isLoggedIn() || !this.ready || !this.online || await this.asyncLock.run(async () => {
+      const n = Date.now(), i = t.model ? [t.model] : t.models;
+      this.syncError = null, this.status = v.Syncing, ne.clear(i);
+      try {
+        if (await D.emit("cloud:sync-started", i), t.refreshUserProfile && await C.refreshUserProfile(), this.syncJob = new cn(i), this.syncJob.listeners.add(t), await re(this.syncJob), this.syncJob.cancelled)
+          return;
+        $e("unit") || await G({ milliseconds: Math.max(500, 1e3 - (Date.now() - n)) }), this.syncJob = null;
+      } catch (l) {
+        if ($e())
+          throw l;
+        this.syncJob = null, this.syncError = l, await Z.report(l, $("cloud.syncFailed", "Sync failed"));
+      } finally {
+        this.status = v.Online, await D.emit("cloud:sync-completed", i);
+      }
+    });
+  }
+  shouldMigrate() {
+    return this.schemaMigrations.size > 0;
+  }
+  async migrate(e) {
+    if (!this.online || !C.isLoggedIn() || !this.ready)
+      throw new Error("Data cannot be migrated at the moment");
+    this.shouldMigrate() && await this.asyncLock.run(async () => {
+      var l;
+      this.status = v.Migrating, this.migrationJob ?? (this.migrationJob = new oe());
+      const t = Date.now(), n = [], i = (l = this.migrationJob).models ?? (l.models = pe());
+      ne.clear(i);
+      try {
+        if (e && n.push(this.migrationJob.listeners.add(e)), await D.emit("cloud:migration-started", i), await re(this.migrationJob), this.migrationJob.cancelled) {
+          await D.emit("cloud:migration-cancelled", i);
+          return;
+        }
+        this.migrationJob = null, this.migrationDismissed = !1, this.migrationPostponed = !1, await G({ milliseconds: Math.max(0, 1e3 - (Date.now() - t)) }), await D.emit("cloud:migration-completed", i);
+      } catch (a) {
+        await Z.report(a, $("cloud.migrationFailed", "Migration failed"));
+      } finally {
+        this.status = v.Online, n.forEach((a) => a == null ? void 0 : a());
+      }
+    });
+  }
+  async register(e, t = {}) {
+    if (this.registeredModels.find((i) => e === i.modelClass))
+      return;
+    const n = this.engine;
+    n && Re(e).forEach((i) => z(i).setEngine(n)), this.whenReady(() => {
+      const [i] = this.modelCollections[e.modelName] ?? [];
+      e.useSoftDeletes(!0), e.collection = i ?? de(e, t.path);
+    }), await Ut(e, {
+      created: (i) => this.ready && Le(i),
+      updated: (i) => this.ready && Ue(i),
+      deleted: (i) => this.ready && ge(/* @__PURE__ */ new Set([i.url ?? i.getDeletedPrimaryKey()]))
+    }), x(e) && k(e).forEach((i) => {
+      const l = e.instance().requireRelation(i).relatedClass;
+      l.on("created", (a) => this.ready && Le(a)), l.on("updated", (a) => this.ready && Ue(a)), l.on(
+        "deleted",
+        (a) => this.ready && ge(/* @__PURE__ */ new Set([a.url ?? a.getDeletedPrimaryKey()]))
+      );
+    }), this.registeredModels.push({ modelClass: e, path: t.path });
+    for (const i of this.modelCollections[e.modelName] ?? [])
+      await te(e, i);
+  }
+  registerSchemaMigration(e, t) {
+    this.schemaMigrations.set(e, t);
+  }
+  requireRemoteCollection(e) {
+    for (const t of this.registeredModels)
+      if (e === t.modelClass)
+        return de(t.modelClass, t.path);
+    throw new Error(`Failed resolving remote collection for '${e.modelName}' model`);
+  }
+  async boot() {
+    await C.booted, C.isLoggedIn() && this.login(C.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()), At(() => {
+      if (this.pollingInterval && clearInterval(this.pollingInterval), !this.pollingEnabled || this.migrationJob) {
+        this.pollingInterval = null;
+        return;
+      }
+      this.pollingInterval = setInterval(() => this.sync(), this.pollingMinutes * 60 * 1e3);
+    }), await this.bustDocumentsCache(), await this.registerModels();
+  }
+  getDirtyLocalModels() {
+    const e = Object.keys(this.localModelUpdates), t = [];
+    for (const { modelClass: n } of this.registeredModels)
+      for (const i of Me(n, { includeSoftDeleted: !0 }))
+        t.push(...this.getModelsIn(e, i));
+    return t;
+  }
+  getModelsIn(e, t) {
+    const n = [];
+    return e.includes(t.url) && n.push(t), U(t) && n.push(
+      ...Je(t).map((i) => this.getModelsIn(e, i)).flat()
+    ), n;
+  }
+  requireEngine() {
+    return this.engine ?? Pe("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 t = new nn();
+    for (const { modelClass: n, path: i } of this.registeredModels) {
+      if (!x(n))
+        continue;
+      for (const [r, c] of Object.entries(e.get(n) ?? {}))
+        t.migrateUrl(n, r, c);
+      const l = n.collection, a = de(n, i);
+      n.collection = a, t.migrateCollection(n, l, a);
+    }
+    await re(t), await D.emit("cloud:backup-completed");
+  }
+  async onApplicationReady() {
+    this.ready || !C.isLoggedIn() || await this.setReady(!pe().some((e) => e.url.startsWith("solid://")));
+  }
+  async onApplicationMounted() {
+    this.syncOnStartup() && await this.sync();
+  }
+  login(e) {
+    const t = [...this.registeredModels].map(({ modelClass: n }) => Re(n)).flat().concat([W]);
+    this.status = v.Online, this.engine = e.engine, z(j).setEngine(this.engine);
+    for (const n of t)
+      z(n).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: v.Disconnected
+    });
+  }
+  syncOnStartup() {
+    return Se("startupSync") ? De(ke("startupSync")) : this.migrationJob ? !1 : this.startupSync;
+  }
+  async bustDocumentsCache() {
+    !Se("bustDocumentsCache") || !De(ke("bustDocumentsCache")) || (await P.booted, await P.clear());
+  }
+  async registerModels() {
+    const e = xt();
+    for (const t of e.values())
+      !Rt(t) || !t.cloud || await this.register(t, typeof t.cloud == "boolean" ? {} : t.cloud);
+  }
+}
+const I = we(un), hn = {
+  viewBox: "0 0 20 20",
+  width: "1.2em",
+  height: "1.2em"
+};
+function fn(o, s) {
+  return h(), M("svg", hn, s[0] || (s[0] = [
+    f("path", {
+      fill: "currentColor",
+      d: "m6 2l2-2h4l2 2h4v2H2V2zM3 6h14l-1 14H4zm5 2v10h1V8zm3 0v10h1V8z"
+    }, null, -1)
+  ]));
+}
+const mn = O({ name: "zondicons-trash", render: fn }), He = /* @__PURE__ */ B({
+  __name: "AccountLoginModal",
+  setup(o) {
+    return (s, e) => (h(), R(d(ze), {
+      title: s.$td("cloud.logIn.title", "Connect account")
+    }, {
+      default: b(() => [
+        u(d(T), {
+          "lang-key": "cloud.logIn.info",
+          "lang-default": "Log in to your [Solid account](https://solidproject.org) to keep data safe across devices."
+        }),
+        u(d(ue), {
+          class: "text-sm",
+          onClick: e[0] || (e[0] = (t) => s.$ui.alert(
+            s.$td("cloud.logIn.learnMore", "What is Solid?"),
+            s.$td(
+              "cloud.logIn.learnMoreMessage",
+              `Solid is a decentralized storage protocol built on top of web standards. If you want to use this app across devices, you can use Solid to keep changes in sync. Even if you use it in a single device, this will also keep your data secure in case your device is lost.
+
+In any case, Focus works 100% offline and you can connect your Solid POD later on. If you've never heard of Solid and you're just trying things out, you can keep using it without an account.
+
+[Learn more](https://solidproject.org)`
+            )
+          ))
+        }, {
+          default: b(() => [
+            K(S(s.$td("cloud.logIn.learnMore", "What is Solid?")), 1)
+          ]),
+          _: 1
+        }),
+        u(d(vt), {
+          "no-loading": "",
+          class: "mt-4"
+        })
+      ]),
+      _: 1
+    }, 8, ["title"]));
+  }
+}), gn = {
+  key: 0,
+  class: "mt-4"
+}, pn = { class: "text-base font-semibold" }, yn = { class: "ml-1" }, wn = /* @__PURE__ */ B({
+  __name: "PurgeData",
+  setup(o) {
+    async function s() {
+      await ae.confirm(
+        $("settings.purgeConfirmTitle", "Delete everything?"),
+        $(
+          "settings.purgeConfirmMessage",
+          "If you proceed, all your data will be deleted forever. If you want to save it before wiping this device, you can [connect to your Solid account](#action:connect) first."
+        ),
+        {
+          acceptVariant: "danger",
+          acceptText: $("settings.purgeConfirmAccept", "Purge data"),
+          actions: { connect: () => ae.modal(He) }
+        }
+      ) && (await ae.closeAllModals(), await nt.purge());
+    }
+    return (e, t) => e.$solid.hasLoggedIn() ? _("", !0) : (h(), M("details", gn, [
+      f("summary", null, [
+        f("span", pn, S(e.$td("settings.dangerZone", "Danger zone")), 1)
+      ]),
+      u(d(q), {
+        variant: "danger",
+        class: "mt-4",
+        onClick: t[0] || (t[0] = (n) => s())
+      }, {
+        default: b(() => [
+          u(d(mn), { class: "size-4" }),
+          f("span", yn, S(e.$td("settings.purge", "Purge data")), 1)
+        ]),
+        _: 1
+      })
+    ]));
+  }
+}), Mn = st([
+  {
+    priority: 0,
+    component: wn
+  }
+]), bn = {
+  viewBox: "0 0 20 20",
+  width: "1.2em",
+  height: "1.2em"
+};
+function Cn(o, s) {
+  return h(), M("svg", bn, s[0] || (s[0] = [
+    f("path", {
+      fill: "currentColor",
+      d: "M2.93 17.07A10 10 0 1 1 17.07 2.93A10 10 0 0 1 2.93 17.07m12.73-1.41A8 8 0 1 0 4.34 4.34a8 8 0 0 0 11.32 11.32M6.7 9.29L9 11.6l4.3-4.3l1.4 1.42L9 14.4l-3.7-3.7l1.4-1.42z"
+    }, null, -1)
+  ]));
+}
+const vn = O({ name: "zondicons-checkmark-outline", render: Cn }), $n = {
+  viewBox: "0 0 24 24",
+  width: "1.2em",
+  height: "1.2em"
+};
+function Sn(o, s) {
+  return h(), M("svg", $n, s[0] || (s[0] = [
+    f("path", {
+      fill: "currentColor",
+      d: "M19.35 10.04A7.49 7.49 0 0 0 12 4C9.11 4 6.6 5.64 5.35 8.04A5.994 5.994 0 0 0 0 14c0 3.31 2.69 6 6 6h13c2.76 0 5-2.24 5-5c0-2.64-2.05-4.78-4.65-4.96M14 13v4h-4v-4H7l5-5l5 5z"
+    }, null, -1)
+  ]));
+}
+const Dn = O({ name: "ic-sharp-cloud-upload", render: Sn }), kn = {
+  viewBox: "0 0 20 20",
+  width: "1.2em",
+  height: "1.2em"
+};
+function Rn(o, s) {
+  return h(), M("svg", kn, s[0] || (s[0] = [
+    f("path", {
+      fill: "currentColor",
+      d: "M3.94 6.5L2.22 3.64l1.42-1.42L6.5 3.94c.52-.3 1.1-.54 1.7-.7L9 0h2l.8 3.24c.6.16 1.18.4 1.7.7l2.86-1.72l1.42 1.42l-1.72 2.86c.3.52.54 1.1.7 1.7L20 9v2l-3.24.8c-.16.6-.4 1.18-.7 1.7l1.72 2.86l-1.42 1.42l-2.86-1.72c-.52.3-1.1.54-1.7.7L11 20H9l-.8-3.24c-.6-.16-1.18-.4-1.7-.7l-2.86 1.72l-1.42-1.42l1.72-2.86c-.3-.52-.54-1.1-.7-1.7L0 11V9l3.24-.8c.16-.6.4-1.18.7-1.7M10 13a3 3 0 1 0 0-6a3 3 0 0 0 0 6"
+    }, null, -1)
+  ]));
+}
+const Ke = O({ name: "zondicons-cog", render: Rn }), Ln = {
+  viewBox: "0 0 24 24",
+  width: "1.2em",
+  height: "1.2em"
+};
+function Un(o, s) {
+  return h(), M("svg", Ln, s[0] || (s[0] = [
+    f("path", {
+      fill: "currentColor",
+      d: "M5 21q-.825 0-1.412-.587T3 19V5q0-.825.588-1.412T5 3h6q.425 0 .713.288T12 4t-.288.713T11 5H5v14h6q.425 0 .713.288T12 20t-.288.713T11 21zm12.175-8H10q-.425 0-.712-.288T9 12t.288-.712T10 11h7.175L15.3 9.125q-.275-.275-.275-.675t.275-.7t.7-.313t.725.288L20.3 11.3q.3.3.3.7t-.3.7l-3.575 3.575q-.3.3-.712.288t-.713-.313q-.275-.3-.262-.712t.287-.688z"
+    }, null, -1)
+  ]));
+}
+const An = O({ name: "material-symbols-logout-rounded", render: Un }), In = {
+  viewBox: "0 0 20 20",
+  width: "1.2em",
+  height: "1.2em"
+};
+function zn(o, s) {
+  return h(), M("svg", In, s[0] || (s[0] = [
+    f("path", {
+      fill: "currentColor",
+      d: "M10 3v2a5 5 0 0 0-3.54 8.54l-1.41 1.41A7 7 0 0 1 10 3m4.95 2.05A7 7 0 0 1 10 17v-2a5 5 0 0 0 3.54-8.54zM10 20l-4-4l4-4zm0-12V0l4 4z"
+    }, null, -1)
+  ]));
+}
+const F = O({ name: "zondicons-refresh", render: zn }), En = {
+  viewBox: "0 0 24 24",
+  width: "1.2em",
+  height: "1.2em"
+};
+function Tn(o, s) {
+  return h(), M("svg", En, s[0] || (s[0] = [
+    f("path", {
+      fill: "currentColor",
+      d: "M6 6h12v12H6z"
+    }, null, -1)
+  ]));
+}
+const qn = O({ name: "ic-baseline-stop", render: Tn }), Pn = {
+  viewBox: "0 0 512 512",
+  width: "1.2em",
+  height: "1.2em"
+};
+function On(o, s) {
+  return h(), M("svg", Pn, s[0] || (s[0] = [
+    f("path", {
+      fill: "currentColor",
+      d: "M449.07 399.08L278.64 82.58c-12.08-22.44-44.26-22.44-56.35 0L51.87 399.08A32 32 0 0 0 80 446.25h340.89a32 32 0 0 0 28.18-47.17m-198.6-1.83a20 20 0 1 1 20-20a20 20 0 0 1-20 20m21.72-201.15l-5.74 122a16 16 0 0 1-32 0l-5.74-121.95a21.73 21.73 0 0 1 21.5-22.69h.21a21.74 21.74 0 0 1 21.73 22.7Z"
+    }, null, -1)
+  ]));
+}
+const H = O({ name: "ion-warning", render: On }), _n = { class: "relative flex items-center rounded-md bg-gray-100 p-4 pr-12" }, xn = { class: "flex flex-col overflow-hidden" }, Jn = { class: "font-semibold" }, Nn = { class: "px-2" }, Wn = {
+  key: 0,
+  class: "mt-4 flex items-center gap-2"
+}, jn = { class: "flex w-full flex-col" }, Bn = {
+  key: 1,
+  class: "mt-4 flex items-center gap-2"
+}, Vn = {
+  key: 2,
+  class: "mt-4 flex items-center gap-2"
+}, Fn = {
+  key: 3,
+  class: "mt-4 flex items-center gap-2"
+}, Hn = {
+  key: 4,
+  class: "mt-4 flex items-center gap-2"
+}, Kn = {
+  key: 5,
+  class: "mt-4 flex items-center gap-2"
+}, Yn = {
+  key: 6,
+  class: "mt-4 flex items-center gap-2"
+}, Qn = { class: "flex flex-col gap-2" }, Zn = { class: "flex items-center" }, Gn = { "aria-hidden": "true" }, Xn = {
+  key: 0,
+  "aria-hidden": "true"
+}, es = {
+  key: 0,
+  class: "mt-4 flex flex-row-reverse justify-start gap-2"
+}, ts = /* @__PURE__ */ B({
+  __name: "AccountModal",
+  setup(o) {
+    const s = It("$modalRef"), e = zt(!1), t = $("cloud.advanced.polling", "Synchronize every {minutes} minutes", {
+      minutes: "%%separator%%"
+    }).split("%%separator%%"), n = Y(() => C.error ?? I.syncError), i = Y(() => {
+      if (n.value)
+        return typeof n.value == "string" ? n.value : $("cloud.info.error", "There has been an error connecting.");
+    }), l = Y(() => n.value && typeof n.value != "string");
+    async function a() {
+      I.syncJob && (e.value = !0, await Promise.race([I.syncJob.cancel(), I.syncJob.completed]), e.value = !1);
+    }
+    return ot("auth:logout", () => {
+      var r;
+      return (r = s.value) == null ? void 0 : r.close();
+    }), (r, c) => (h(), R(d(ze), {
+      ref: "$modalRef",
+      "title-hidden": "",
+      "close-hidden": "",
+      title: r.$td("account.title", "Account")
+    }, {
+      default: b(() => {
+        var p, m;
+        return [
+          f("div", _n, [
+            u(d(_e), { class: "mr-2 size-16 shrink-0" }),
+            f("div", xn, [
+              f("span", Jn, S(((p = r.$solid.user) == null ? void 0 : p.name) ?? r.$td("user.anonymous", "Anonymous")), 1),
+              u(d(ue), {
+                href: (m = r.$solid.user) == null ? void 0 : m.webId,
+                class: "mt-0.5 truncate text-sm font-light text-gray-500"
+              }, {
+                default: b(() => {
+                  var g;
+                  return [
+                    K(S((g = r.$solid.user) == null ? void 0 : g.webId), 1)
+                  ];
+                }),
+                _: 1
+              }, 8, ["href"])
+            ]),
+            u(d(q), {
+              size: "icon",
+              variant: "ghost",
+              class: "absolute top-1 right-1 hover:bg-gray-200",
+              "aria-label": r.$td("user.settings", "Settings"),
+              title: r.$td("user.settings", "Settings"),
+              onClick: c[0] || (c[0] = (g) => r.$ui.modal(d(Ee)))
+            }, {
+              default: b(() => [
+                u(d(Ke), { class: "size-5" })
+              ]),
+              _: 1
+            }, 8, ["aria-label", "title"])
+          ]),
+          f("div", Nn, [
+            r.$cloud.syncing ? (h(), M("div", Wn, [
+              u(d(F), { class: "mt-0.5 size-6 shrink-0 animate-spin self-start text-green-500" }),
+              f("div", jn, [
+                u(d(T), {
+                  "lang-key": "cloud.info.syncing",
+                  "lang-default": "Synchronizing..."
+                }),
+                r.$cloud.syncJob ? (h(), R(d(it), {
+                  key: 0,
+                  job: r.$cloud.syncJob,
+                  "filled-class": "bg-green-500"
+                }, null, 8, ["job"])) : _("", !0)
+              ])
+            ])) : r.$solid.loginOngoing ? (h(), M("div", Bn, [
+              u(d(F), { class: "mt-0.5 size-6 shrink-0 animate-spin self-start text-green-500" }),
+              u(d(T), {
+                "lang-key": "cloud.info.reconnecting",
+                "lang-default": "Reconnecting..."
+              })
+            ])) : n.value ? (h(), M("div", Vn, [
+              u(d(H), { class: "mt-0.5 size-6 shrink-0 self-start text-red-500" }),
+              f("div", null, [
+                u(d(T), { text: i.value }, null, 8, ["text"]),
+                l.value ? (h(), R(d(ue), {
+                  key: 0,
+                  class: "text-sm text-red-700 opacity-50 hover:opacity-75 focus-visible:opacity-75",
+                  onClick: c[1] || (c[1] = (g) => r.$errors.inspect(n.value))
+                }, {
+                  default: b(() => [
+                    K(S(r.$td("errors.viewDetails", "View details")), 1)
+                  ]),
+                  _: 1
+                })) : _("", !0)
+              ])
+            ])) : r.$cloud.ready ? r.$cloud.dirty ? (h(), M("div", Hn, [
+              u(d(H), { class: "mt-0.5 size-6 shrink-0 self-start text-yellow-500" }),
+              u(d(T), {
+                "lang-key": "cloud.info.changes",
+                "lang-default": "Everything is up to date. | There is one local change. | There are {n} local changes.",
+                "lang-params": r.$cloud.localChanges
+              }, null, 8, ["lang-params"])
+            ])) : r.$cloud.online ? (h(), M("div", Kn, [
+              u(d(vn), { class: "mt-0.5 size-6 shrink-0 self-start text-green-500" }),
+              u(d(T), {
+                "lang-key": "cloud.info.changes",
+                "lang-default": "Everything is up to date.",
+                "lang-params": 0
+              })
+            ])) : (h(), M("div", Yn, [
+              u(d(H), { class: "mt-0.5 size-6 shrink-0 self-start text-yellow-500" }),
+              u(d(T), {
+                "lang-key": "cloud.info.disconnected",
+                "lang-default": "You are disconnected from your Solid account, all the changes you make will remain in your device."
+              })
+            ])) : (h(), M("div", Fn, [
+              u(d(H), { class: "mt-0.5 size-6 shrink-0 self-start text-yellow-500" }),
+              u(d(T), {
+                "lang-key": "cloud.info.setup",
+                "lang-default": "Your data is not backed up yet."
+              })
+            ])),
+            u(d(rt), { class: "mt-2" }, {
+              default: b(() => [
+                f("ul", Qn, [
+                  f("li", null, [
+                    u(d(le), {
+                      modelValue: r.$solid.autoReconnect,
+                      "onUpdate:modelValue": c[2] || (c[2] = (g) => r.$solid.autoReconnect = g),
+                      "label-class": "text-base",
+                      label: r.$td("cloud.advanced.reconnect", "Reconnect on startup")
+                    }, null, 8, ["modelValue", "label"])
+                  ]),
+                  f("li", null, [
+                    u(d(le), {
+                      modelValue: r.$cloud.startupSync,
+                      "onUpdate:modelValue": c[3] || (c[3] = (g) => r.$cloud.startupSync = g),
+                      "label-class": "text-base",
+                      label: r.$td("cloud.advanced.startupSync", "Synchronize on startup")
+                    }, null, 8, ["modelValue", "label"])
+                  ]),
+                  f("li", null, [
+                    u(d(le), {
+                      modelValue: r.$cloud.pollingEnabled,
+                      "onUpdate:modelValue": c[5] || (c[5] = (g) => r.$cloud.pollingEnabled = g),
+                      "label-class": "text-base"
+                    }, {
+                      default: b(() => [
+                        f("div", Zn, [
+                          f("span", Gn, S(d(t)[0]), 1),
+                          u(d(at), {
+                            type: "number",
+                            text: `${r.$cloud.pollingMinutes}`,
+                            "aria-label": r.$td("cloud.advanced.pollingMinutes", "Synchronization interval (in minutes)"),
+                            class: "focus-within:border-primary-600 mx-1 -mb-px border-b",
+                            onUpdate: c[4] || (c[4] = (g) => r.$cloud.pollingMinutes = g)
+                          }, {
+                            default: b(() => [
+                              K(S(r.$cloud.pollingMinutes), 1)
+                            ]),
+                            _: 1
+                          }, 8, ["text", "aria-label"]),
+                          d(t).length > 1 ? (h(), M("span", Xn, S(d(t)[1]), 1)) : _("", !0)
+                        ])
+                      ]),
+                      _: 1
+                    }, 8, ["modelValue"])
+                  ])
+                ])
+              ]),
+              _: 1
+            })
+          ]),
+          r.$solid.loginOngoing ? _("", !0) : (h(), M("div", es, [
+            r.$cloud.syncing ? (h(), R(d(q), {
+              key: 0,
+              variant: "secondary",
+              disabled: e.value,
+              onClick: c[6] || (c[6] = (g) => a())
+            }, {
+              default: b(() => [
+                u(d(qn), { class: "size-5" }),
+                f("span", null, S(e.value ? r.$td("cloud.stopping", "Stopping...") : r.$td("cloud.stop", "Stop synchronization")), 1)
+              ]),
+              _: 1
+            }, 8, ["disabled"])) : r.$solid.isLoggedIn() ? r.$cloud.ready ? (h(), R(d(q), {
+              key: 2,
+              onClick: c[8] || (c[8] = (g) => r.$cloud.sync({ refreshUserProfile: !0 }))
+            }, {
+              default: b(() => [
+                u(d(F), { class: "size-5" }),
+                f("span", null, S(r.$td("cloud.sync", "Synchronize")), 1)
+              ]),
+              _: 1
+            })) : (h(), R(d(q), {
+              key: 3,
+              onClick: c[9] || (c[9] = (g) => {
+                var J;
+                return r.$cloud.setupDismissed = !1, (J = d(s)) == null ? void 0 : J.close();
+              })
+            }, {
+              default: b(() => [
+                u(d(Dn), { class: "size-5" }),
+                f("span", null, S(r.$td("cloud.setup.submit", "Back up now")), 1)
+              ]),
+              _: 1
+            })) : (h(), R(d(q), {
+              key: 1,
+              onClick: c[7] || (c[7] = (g) => r.$solid.reconnect({ force: !0 }))
+            }, {
+              default: b(() => [
+                u(d(F), { class: "size-5" }),
+                f("span", null, S(r.$td("cloud.reconnect", "Reconnect")), 1)
+              ]),
+              _: 1
+            })),
+            r.$cloud.syncing ? _("", !0) : (h(), R(d(q), {
+              key: 4,
+              variant: "secondary",
+              onClick: c[10] || (c[10] = (g) => r.$solid.logout())
+            }, {
+              default: b(() => [
+                u(d(An), { class: "size-5" }),
+                f("span", null, S(r.$cloud.ready ? r.$td("cloud.logOut", "Log out") : r.$td("cloud.disconnect", "Disconnect")), 1)
+              ]),
+              _: 1
+            }))
+          ]))
+        ];
+      }),
+      _: 1
+    }, 8, ["title"]));
+  }
+}), ns = { class: "relative size-12" }, ss = ["aria-label", "title"], os = {
+  key: 0,
+  class: "absolute -inset-1 animate-spin rounded-full border-2 border-[currentColor_transparent] text-green-500"
+}, is = { class: "sr-only" }, rs = /* @__PURE__ */ B({
+  __name: "AccountLoggedIn",
+  setup(o) {
+    const s = Y(() => I.syncing || C.loginOngoing ? {
+      loading: !0,
+      classes: "bg-green-500 sr-only",
+      message: e() ?? ""
+    } : C.error || I.syncError ? {
+      classes: "bg-red-500",
+      message: $("account.error", "There has been an error connecting with your account.")
+    } : !C.isLoggedIn() || I.dirty || !I.ready ? {
+      classes: "bg-yellow-500",
+      message: $(
+        "account.dirty",
+        "There are local changes that haven't been synchronized yet."
+      )
+    } : {
+      classes: "bg-green-500",
+      message: e() ?? ""
+    });
+    function e() {
+      switch (I.status) {
+        case v.Syncing:
+          return $("cloud.status.syncing", "Synchronization in progress");
+        case v.Migrating:
+          return $("cloud.status.migrating", "Migration in progress");
+        case v.Online:
+          return $("cloud.status.online", "Online");
+        case v.Disconnected:
+          return $("cloud.status.disconnected", "Disconnected");
+      }
+    }
+    return (t, n) => (h(), M("div", ns, [
+      f("button", {
+        class: "clickable focus-visible:outline-primary-600 flex size-full rounded-full focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2",
+        type: "button",
+        "aria-label": t.$td("account.open", "Open account"),
+        title: t.$td("account.open", "Open account"),
+        onClick: n[0] || (n[0] = (i) => t.$ui.modal(ts))
+      }, [
+        u(d(_e), { class: "size-full" }),
+        s.value.loading ? (h(), M("div", os)) : _("", !0)
+      ], 8, ss),
+      f("div", {
+        class: Et(["pointer-events-none absolute right-0 bottom-0 size-3 rounded-full border-2 border-white", s.value.classes])
+      }, [
+        f("span", is, S(s.value.message), 1)
+      ], 2)
+    ]));
+  }
+}), as = /* @__PURE__ */ B({
+  __name: "AccountLoggedOut",
+  setup(o) {
+    return (s, e) => (h(), R(d(lt), {
+      align: "start",
+      options: [
+        { label: s.$td("user.logIn", "Connect account"), click: () => s.$ui.modal(He) },
+        { label: s.$td("user.settings", "Settings"), click: () => s.$ui.modal(d(Ee)) }
+      ]
+    }, {
+      default: b(() => [
+        u(d(q), {
+          size: "icon",
+          variant: "ghost",
+          "aria-label": s.$td("user.menu", "Configuration"),
+          title: s.$td("user.menu", "Configuration")
+        }, {
+          default: b(() => [
+            u(d(Ke), { class: "size-5" })
+          ]),
+          _: 1
+        }, 8, ["aria-label", "title"])
+      ]),
+      _: 1
+    }, 8, ["options"]));
+  }
+}), Ms = /* @__PURE__ */ B({
+  __name: "Account",
+  setup(o) {
+    return (s, e) => s.$solid.hasLoggedIn() ? (h(), R(rs, { key: 0 })) : (h(), R(as, { key: 1 }));
+  }
+}), ls = { $cloud: I };
+function bs() {
+  return {
+    name: "@aerogel/local-first",
+    async install(o) {
+      Mn.forEach((s) => se.addSetting(s)), await ct(o, {
+        ...ls,
+        $_documentsCache: P
+      });
+    }
+  };
+}
+export {
+  Ms as Account,
+  rs as AccountLoggedIn,
+  as as AccountLoggedOut,
+  He as AccountLoginModal,
+  ts as AccountModal,
+  I as Cloud,
+  un as CloudService,
+  bs as default
+};
+//# sourceMappingURL=aerogel-plugin-local-first.js.map