@aerogel/plugin-local-first 0.0.0-next.0d1cf82f9dfbe1d3e7ec5644f85f97a43c8c2334

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

@@ -0,0 +1,1098 @@
+var ke = Object.defineProperty;
+var Ee = (s, i, e) => i in s ? ke(s, i, { enumerable: !0, configurable: !0, writable: !0, value: e }) : s[i] = e;
+var h = (s, i, e) => Ee(s, typeof i != "symbol" ? i + "" : i, e);
+import { App as Z, Job as ee, Service as qe, Events as m, defineServiceState as xe, replaceExisting as oe, translateWithDefault as U, dispatch as F, Errors as re, AGMarkdown as ae, AGButton as ce, bootServices as Oe } from "@aerogel/core";
+import { arrayFilter as Te, isInstanceOf as S, facade as te, after as q, arrayRemove as $e, required as M, tap as we, toString as Je, urlRoute as Ne, urlResolveDirectory as ze, objectWithout as Fe, requireUrlParentDirectory as x, fail as Me, IndexedDBMap as We, arrayFrom as je, map as b, arrayChunk as Ke, mixed as Ce, objectMap as Be, round as He, Semaphore as _e, isArray as Ge, isTesting as le, hasLocationQueryParameter as Qe, parseBoolean as Ye, getLocationQueryParameter as Ve } from "@noeldemartin/utils";
+import { Solid as g, AGSolidStatus as Xe } from "@aerogel/plugin-solid";
+import { SolidModel as L, SolidContainsRelation as be, isContainerClass as A, SolidContainer as J, SolidACLAuthorization as Ze, SolidDocument as et, Metadata as tt, Operation as nt, isContainer as R, Tombstone as v, PropertyOperation as O } from "soukai-solid";
+import { getTrackedModels as ne, trackModelsCollection as T, ignoreModelsCollection as st, trackModels as it } from "@aerogel/plugin-soukai";
+import { watchEffect as ot, defineComponent as rt, createBlock as de, openBlock as W, unref as I, withCtx as j, createElementBlock as at, createVNode as K, createTextVNode as ue, toDisplayString as he } from "vue";
+import { bootModels as ct, requireEngine as lt, DocumentNotFound as dt } from "soukai";
+import { MalformedSolidDocumentError as Re } from "@noeldemartin/solid-utils";
+const B = /* @__PURE__ */ new WeakMap();
+function _(s) {
+  return Te(
+    y(s).map((i) => {
+      const e = s.instance().requireRelation(i).relatedClass;
+      return A(e) ? !1 : e;
+    })
+  );
+}
+function y(s) {
+  return B.has(s) || B.set(
+    s,
+    s.relations.filter((i) => L.reservedRelations.includes(i) ? !1 : s.instance().requireRelation(i) instanceof be)
+  ), B.get(s) ?? [];
+}
+function Se(s) {
+  return y(s.static()).reduce(
+    (e, t) => e.concat(s.getRelationModels(t) ?? []),
+    []
+  );
+}
+function fe(s) {
+  const i = /* @__PURE__ */ new Set(), e = s.instance();
+  i.add(s);
+  for (const t of s.relations)
+    s.reservedRelations.includes(t) || i.add(e.requireRelation(t).relatedClass);
+  return [...i.values()];
+}
+function G(s) {
+  return s.getRelatedModels().filter(
+    (i) => !S(i, Ze) && !S(i, et) && !S(i, tt) && !S(i, nt) && i.static() !== J
+  );
+}
+function De(s) {
+  if (s.isDirty())
+    return !0;
+  if (!(s instanceof J))
+    return !1;
+  const i = (e) => {
+    var t;
+    return (t = s.getRelationModels(e)) == null ? void 0 : t.some((n) => De(n));
+  };
+  return y(s.static()).some(i);
+}
+const ut = M(() => Z.service("$cloud"));
+class ht {
+  constructor() {
+    h(this, "models", /* @__PURE__ */ new Set());
+    h(this, "promises", []);
+  }
+  push(i) {
+    this.models.add(i), this.syncAfter(q({ seconds: 1 }));
+  }
+  clear(i) {
+    if (!i) {
+      this.models = /* @__PURE__ */ new Set();
+      return;
+    }
+    for (const e of i)
+      this.models.delete(e);
+  }
+  async syncAfter(i) {
+    const e = typeof i == "function" ? i() : i;
+    return this.promises.push(e), e.then(() => $e(this.promises, e)), this.promises.length === 1 && this.schedule(), e;
+  }
+  schedule() {
+    Promise.all(this.promises).then(() => q()).then(() => {
+      if (this.promises.length !== 0) {
+        this.schedule();
+        return;
+      }
+      const i = this.consume();
+      i.length !== 0 && ut.syncIfOnline(i);
+    });
+  }
+  consume() {
+    const i = [], e = /* @__PURE__ */ new Set();
+    for (const t of this.models)
+      R(t) && (this.models.delete(t), Se(t).forEach((n) => e.add(n)), i.push(t));
+    for (const t of this.models)
+      this.models.delete(t), !e.has(t) && i.push(t);
+    return i;
+  }
+}
+const $ = te(ht), d = M(() => Z.service("$cloud")), Ue = /* @__PURE__ */ new WeakMap(), se = /* @__PURE__ */ new WeakMap();
+function ft(s) {
+  const i = s.getRelatedModels().concat([s]);
+  for (const e of i)
+    e.cleanDirty(!0);
+}
+function mt(s) {
+  const i = G(s).concat([s]);
+  for (const e of i) {
+    if (!e.operations || e.operations.length === 0)
+      continue;
+    const t = (e.operations ?? []).filter((n) => !(n instanceof O) || !e.ignoreRdfPropertyHistory(n.property, !0));
+    if (!t.some((n) => !n.isInception(e))) {
+      e.setRelationModels("operations", []);
+      continue;
+    }
+    e.setRelationModels("operations", t);
+  }
+}
+async function me(s) {
+  d.setState({
+    localModelUpdates: {
+      ...d.localModelUpdates,
+      [s.url]: 1
+    }
+  }), Rt(s.static()) && await Q(s.static(), x(s.url)), d.autoPush && d.ready && !d.syncing && $.push(s);
+}
+async function Q(s, i) {
+  var e;
+  (e = d.modelCollections[s.modelName]) != null && e.includes(i) || (d.setState("modelCollections", {
+    ...d.modelCollections,
+    [s.modelName]: (d.modelCollections[s.modelName] ?? []).concat(i)
+  }), await T(s, i));
+}
+async function ge(s) {
+  if (gt(s))
+    return;
+  const i = d.localModelUpdates[s.url] ?? 0;
+  d.setState({
+    localModelUpdates: s.isSoftDeleted() ? Fe(d.localModelUpdates, s.url) : {
+      ...d.localModelUpdates,
+      [s.url]: i + 1
+    }
+  }), d.autoPush && d.ready && !d.syncing && $.push(s);
+}
+function Y(s, i) {
+  const e = s == null ? void 0 : s.map((n) => Je(n.getDeletedPrimaryKey() ?? n.getPrimaryKey())), t = {};
+  for (const [n, o] of Object.entries(d.localModelUpdates)) {
+    const r = Ne(n);
+    (!e || e.some(
+      (c) => n === c || c.endsWith("/") && n.startsWith(c)
+    )) && !(i != null && i.has(r)) || (t[n] = o);
+  }
+  d.setState({ localModelUpdates: t });
+}
+function ie(s, i = {}) {
+  const e = /* @__PURE__ */ new Set();
+  if (e.add(s.static()), s instanceof J)
+    for (const n of y(s.static()))
+      e.add(s.requireRelation(n).relatedClass);
+  const t = [...e.values()].map(
+    (n) => [n, D(n)]
+  );
+  return we(s.clone({ constructors: t }), (n) => {
+    mt(n), i.clean && ft(n);
+  });
+}
+function Le(s) {
+  const i = /* @__PURE__ */ new Set();
+  if (i.add(s.static()), s instanceof J)
+    for (const t of y(s.static()))
+      i.add(s.requireRelation(t).relatedClass);
+  const e = [...i.values()].map(
+    (t) => [t, Dt(t)]
+  );
+  return s.clone({ constructors: e });
+}
+async function pe(s, i, e) {
+  const t = D(v), n = i.map((a) => a.url), o = s.filter((a) => !n.includes(a.url)).map((a) => a.requireDocumentUrl()).filter((a) => !e.has(a)), r = await t.all({ $in: o });
+  return i.concat(r);
+}
+function gt(s) {
+  var e;
+  const i = (e = s.metadata.updatedAt) == null ? void 0 : e.getTime();
+  return !s.operations.some((t) => t.date.getTime() !== i ? !1 : t instanceof O ? !s.ignoreRdfPropertyHistory(t.property, !0) : !0);
+}
+function pt(s, i) {
+  return i.get(s.url) ?? Le(s);
+}
+function V() {
+  return [...d.registeredModels].map(({ modelClass: s }) => ne(s)).flat();
+}
+function yt() {
+  return d.schemaMigrations;
+}
+function wt() {
+  d.schemaMigrations.clear();
+}
+function ye(s) {
+  return d.schemaMigrations.get(s);
+}
+function D(s) {
+  return Ue.get(s) ?? St(s);
+}
+function H(s) {
+  const i = g.requireUser().storageUrls[0];
+  return s ? ze((s.startsWith("/") ? i.slice(0, -1) : i) + s) : i;
+}
+function Mt(s, i) {
+  return i.get(s.url) ?? ie(s);
+}
+function Ct(s) {
+  for (const { modelClass: i } of d.registeredModels)
+    if (ne(i).some((t) => t.url === s.url))
+      return !0;
+  return !1;
+}
+function X(s) {
+  return se.has(s.static());
+}
+function bt(s) {
+  return !X(s);
+}
+function Rt(s) {
+  return d.registeredModels.some(({ modelClass: i }) => i === s);
+}
+function St(s) {
+  var n;
+  const i = s, e = (o, r) => {
+    o.timestamps = i.timestamps, o.history = i.history, r(), o.timestamps = [], o.history = !1;
+  }, t = (n = class extends i {
+    initialize(o, r) {
+      e(this._proxy.static(), () => super.initialize(o, r));
+    }
+    initializeRelations() {
+      super.initializeRelations();
+      for (const o of Object.values(this._relations))
+        o instanceof be && (o.relatedClass = D(o.relatedClass));
+    }
+    fixMalformedAttributes() {
+      e(this.static(), () => super.fixMalformedAttributes());
+    }
+  }, h(n, "timestamps", !1), h(n, "history", !1), n);
+  return Ue.set(i, t), se.set(t, i), i.on("schema-updated", async (o) => {
+    await t.updateSchema({
+      ...o,
+      timestamps: !1,
+      history: !1
+    });
+  }), ct({ [`Remote${s.modelName}`]: t }), t;
+}
+function Dt(s) {
+  return se.get(s) ?? Me(`Couldn't find local class for ${s.modelName}`);
+}
+class Ut extends ee {
+  constructor() {
+    super(...arguments);
+    h(this, "urlMigrations", []);
+    h(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 = lt(), t = await e.getCollections();
+    for (const n of t) {
+      const o = await e.readMany(n);
+      for (const [r, a] of Object.entries(o)) {
+        const c = this.replaceUrl(r);
+        await e.create(x(c), this.replaceDocumentUrls(a), c), await e.delete(n, r);
+      }
+    }
+    for (const { modelClass: n, remote: o } of this.urlMigrations)
+      T(n, x(o), { refresh: !1 });
+    for (const { modelClass: n, local: o, remote: r } of this.collectionMigrations)
+      st(n, o), T(n, r, { 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;
+  }
+}
+class Lt extends qe {
+  constructor() {
+    super(...arguments);
+    h(this, "cache", new We("documents-cache"));
+  }
+  async isFresh(e, t) {
+    const n = await this.cache.get(e), o = typeof t != "number" ? t.getTime() : t;
+    return !!(n != null && n.modifiedAt) && n.modifiedAt >= o;
+  }
+  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 boot() {
+    m.on("auth:logout", async () => {
+      await this.cache.clear(), this.cache.close();
+    });
+  }
+}
+const k = te(Lt);
+function At(s) {
+  const i = {};
+  return async () => ("value" in i || (i.value = await s()), i.value);
+}
+class Ae {
+  async loadContainedModels(i, e = {}) {
+    var u;
+    if (bt(i)) {
+      const f = [];
+      for (const w of y(i.static())) {
+        const C = await i.loadRelationIfUnloaded(w) ?? [];
+        f.push(...je(C));
+      }
+      return f;
+    }
+    const t = {}, n = [], o = b(i.documents, "url"), r = Ke(i.resourceUrls, 10), a = r.flat().map((f) => ({
+      documentUrl: f,
+      completed: !1
+    })), c = b(a, "documentUrl");
+    e.status && (e.status.children = a);
+    for (const f of r) {
+      await Promise.all(
+        f.map(async (w) => {
+          const { children: C, tombstones: E } = await this.loadDocumentChildren(i, w, o, e.onMalformedDocument);
+          n.push(...E);
+          for (const [z, Pe] of Object.entries(C))
+            (t[z] ?? (t[z] = [])).push(...Pe);
+        })
+      );
+      for (const w of f)
+        w.endsWith("/") || (M(c.get(w)).completed = !0);
+      await ((u = e.onLoaded) == null ? void 0 : u.call(e, f));
+    }
+    for (const [f, w] of Object.entries(t))
+      i.setRelationModels(f, w);
+    const l = e.ignoreTombstones ? Object.values(t).flat() : Object.values(t).flat().concat(n);
+    return e.status && (e.status.children = l.map((f) => M(c.get(f.requireDocumentUrl())))), l;
+  }
+  async loadDocumentChildren(i, e, t, n) {
+    var r;
+    const o = t.get(e);
+    return o && await k.isFresh(o.url, o.updatedAt ?? /* @__PURE__ */ new Date()) && ((r = this.localModels) != null && r.hasKey(i.url)) ? {
+      children: await this.loadDocumentChildrenFromLocal(i, o),
+      tombstones: []
+    } : this.loadDocumentChildrenFromRemote(i, e, n);
+  }
+  async loadDocumentChildrenFromLocal(i, e) {
+    var n, o;
+    const t = {};
+    for (const r of y(i.static())) {
+      const a = i.requireRelation(r);
+      if (a.loaded) {
+        t[r] = a.getLoadedModels();
+        continue;
+      }
+      const c = ((o = (n = this.localModels) == null ? void 0 : n.get(i.url)) == null ? void 0 : o.getRelationModels(r)) ?? [];
+      t[r] = c.filter((l) => l.getDocumentUrl() === e.url).map((l) => ie(l, { clean: !0 }));
+    }
+    return t;
+  }
+  async loadDocumentChildrenFromRemote(i, e, t) {
+    const n = {}, o = [], r = At(async () => {
+      try {
+        const a = await i.requireEngine().readOne(i.static("collection"), e), c = await v.createManyFromEngineDocuments({
+          [e]: a
+        });
+        return o.push(...c), a;
+      } catch (a) {
+        if (S(a, dt))
+          return null;
+        if (S(a, Re))
+          return console.warn(a.message), await (t == null ? void 0 : t(e)), null;
+        throw a;
+      }
+    });
+    for (const a of y(i.static())) {
+      const c = i.requireRelation(a);
+      if (c.loaded) {
+        n[a] = c.getLoadedModels();
+        continue;
+      }
+      const l = await r();
+      if (!l)
+        continue;
+      const u = await c.relatedClass.createManyFromEngineDocuments({
+        [e]: l
+      });
+      n[a] = u;
+    }
+    return { children: n, tombstones: o };
+  }
+}
+const P = /* @__PURE__ */ new WeakMap();
+class ve {
+  async loadTypeIndex(i = {}) {
+    const e = g.requireUser();
+    return i.create && !P.get(e) ? P.set(e, await g.findOrCreatePrivateTypeIndex()) : P.has(e) || P.set(e, await g.findPrivateTypeIndex()), P.get(e) ?? null;
+  }
+}
+class Ie {
+  async indexLocalModels(i) {
+    for (const e of i)
+      await this.addLocalModel(e);
+  }
+  async addLocalModel(i) {
+    if (!(!this.localModels || this.localModels.hasKey(i.url))) {
+      this.localModels.add(i);
+      for (const e of y(i.static()))
+        await i.loadRelationIfUnloaded(e);
+      for (const e of i.getRelatedModels())
+        await this.addLocalModel(e);
+    }
+  }
+}
+const vt = ee;
+class N extends Ce(vt, [Ae, ve, Ie]) {
+  constructor() {
+    super(...arguments);
+    h(this, "_models");
+  }
+  static restore(e) {
+    return we(new N(), (t) => {
+      t.status = e;
+    });
+  }
+  get models() {
+    return this._models;
+  }
+  set models(e) {
+    if (!e) {
+      delete this._models, delete this.localModels;
+      return;
+    }
+    const t = Be(this.status.children ?? [], "modelUrl");
+    this._models = e, this.localModels = b([], "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 o = this.models.find(({ url: r }) => n.modelUrl === r);
+      !o || n.completed || (await this.migrateRegisteredModel(o, n, t), await this.updateProgress(() => n.completed = !0));
+    }
+    for (const [n, o] of yt())
+      await n.updateSchema(o);
+    wt();
+  }
+  async migrateRegisteredModel(e, t, n) {
+    if (await this.migrate(e, t), !R(e))
+      return;
+    const o = _(e.static()), r = n == null ? void 0 : n.registrations.find(({ instanceContainer: a }) => a === e.url);
+    !n || !r || o.length === 0 || (r.setAttribute(
+      "forClass",
+      o.map((a) => {
+        var c;
+        return ((c = ye(a)) == null ? void 0 : c.rdfsClasses) ?? a.rdfsClass;
+      }).flat()
+    ), await n.save());
+  }
+  async migrate(e, t) {
+    this.assertNotCancelled(), await this.migrateChildren(e, t);
+    const n = ye(e.static());
+    if (!n)
+      return;
+    const o = await D(e.static()).find(e.url), r = await (o == null ? void 0 : o.migrateSchema(n));
+    await e.migrateSchema(n, {
+      mintOperationUrl: (a) => {
+        var c, l;
+        return (l = (c = r == null ? void 0 : r.operations) == null ? void 0 : c.find((u) => !S(a, O) || !S(u, O) ? !1 : a.property === u.property && a.date.getTime() === u.date.getTime())) == null ? void 0 : l.url;
+      }
+    });
+  }
+  async migrateChildren(e, t) {
+    if (!R(e))
+      return;
+    const n = await this.loadContainedModels(e, { ignoreTombstones: !0 });
+    t.children ?? (t.children = n.map((o) => ({
+      modelUrl: o.url,
+      completed: !1
+    })));
+    for (const o of t.children) {
+      const r = n.find(({ url: a }) => o.modelUrl === a);
+      !r || o.completed || (await this.migrate(r, o), await this.updateProgress(() => o.completed = !0));
+    }
+  }
+}
+const It = M(() => Z.service("$cloud")), Pt = ee;
+function kt(s) {
+  return !!s && "root" in s;
+}
+class Et extends Ce(Pt, [Ae, ve, Ie]) {
+  constructor(e) {
+    super();
+    h(this, "models");
+    h(this, "dirtyRemoteModels");
+    h(this, "rootLocalModels");
+    h(this, "tombstones");
+    h(this, "malformedDocuments");
+    h(this, "documentsModifiedAt");
+    h(this, "localModels");
+    this.models = e, this.rootLocalModels = [], this.localModels = b([], "url"), this.tombstones = b([], "resourceUrl"), this.malformedDocuments = /* @__PURE__ */ new Set(), this.documentsModifiedAt = {};
+  }
+  async run() {
+    const e = g.requireAuthenticator().engine, t = (o, { headers: r }) => {
+      const a = r == null ? void 0 : r.get("last-modified");
+      !a || o.endsWith("/") || (this.documentsModifiedAt[o] = new Date(a));
+    }, n = e.listeners.add({
+      onDocumentRead: t,
+      onDocumentUpdated: t
+    });
+    try {
+      this.rootLocalModels = this.models ?? V(), await this.indexLocalModels(this.rootLocalModels), await this.pullChanges(), await this.pushChanges();
+    } finally {
+      n();
+    }
+  }
+  getInitialStatus() {
+    return {
+      root: !0,
+      completed: !1,
+      children: [{ completed: !1 }, { completed: !1 }]
+    };
+  }
+  calculateCurrentProgress(e) {
+    return e ?? (e = this.status), kt(e) ? He(
+      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 = b(e, (n) => n instanceof v ? 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 o = e[n], r = t[n];
+      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 [n, o] of Object.entries(this.documentsModifiedAt))
+      await k.remember(n, o);
+    Y(this.models, this.malformedDocuments), await this.updateProgress((n) => n.children[1].completed = !0);
+  }
+  async fetchRemoteModels() {
+    const e = this.status.children[0], t = await this.loadTypeIndex();
+    if (!t)
+      return [];
+    const n = [], o = /* @__PURE__ */ new Set(), r = [...It.registeredModels].map(({ modelClass: c }) => {
+      const l = A(c) ? _(c) : [];
+      return {
+        modelClass: c,
+        rdfsClasses: l.length > 0 ? l.map((u) => u.rdfsClasses).flat() : c.rdfsClasses
+      };
+    }), a = t.registrations.map((c) => {
+      const l = r.find(
+        ({ rdfsClasses: u }) => !!c.instanceContainer && u.some((f) => c.forClass.includes(f))
+      );
+      return !l || !c.instanceContainer || o.has(c.instanceContainer) ? null : (o.add(c.instanceContainer), [c, l]);
+    }).filter((c) => !!c);
+    e.children = a.map(() => ({ completed: !1 }));
+    for (let c = 0; c < a.length; c++)
+      await this.ignoringMalformedDocumentErrors(async () => {
+        var w;
+        const l = M(a[c])[0], u = M(a[c])[1], f = D(u.modelClass);
+        if (l.instanceContainer) {
+          if (A(f)) {
+            await Q(
+              u.modelClass,
+              x(l.instanceContainer)
+            );
+            const C = await f.find(l.instanceContainer);
+            C && (await this.loadChildren(C, M((w = e.children) == null ? void 0 : w[c])), n.push(C)), await this.updateProgress(() => {
+              var E;
+              return M((E = e.children) == null ? void 0 : E[c]).completed = !0;
+            });
+            return;
+          }
+          await Q(u.modelClass, l.instanceContainer), n.push(...await f.from(l.instanceContainer).all()), await this.updateProgress(() => {
+            var C;
+            return M((C = e.children) == null ? void 0 : C[c]).completed = !0;
+          });
+        }
+      });
+    return pe(this.rootLocalModels, n, this.malformedDocuments);
+  }
+  async fetchRemoteModelsForLocal(e) {
+    const t = [], n = 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 = n[o], c = await D(r.static()).find(r.url);
+        if (!c) {
+          await this.updateProgress(() => a.completed = !0);
+          return;
+        }
+        R(c) && await this.loadChildren(c, a), t.push(c), await this.updateProgress(() => a.completed = !0);
+      });
+    return pe(e, t, this.malformedDocuments);
+  }
+  async updateTypeRegistrations(e) {
+    if (!R(e) || !Ct(e))
+      return;
+    const t = _(e.static());
+    if (t.length === 0)
+      return;
+    const n = await this.loadTypeIndex({ create: !0 });
+    n.registrations.some((o) => o.instanceContainer === e.url) || await e.register(n, t);
+  }
+  async loadChildren(e, t) {
+    var o, r;
+    if (this.assertNotCancelled(), !R(e))
+      return;
+    const n = await this.loadContainedModels(e, {
+      status: t,
+      onLoaded: async () => {
+        this.assertNotCancelled(), await this.updateProgress();
+      },
+      onMalformedDocument: (a) => this.malformedDocuments.add(a)
+    });
+    for (let a = 0; a < n.length; a++) {
+      const c = n[a];
+      if (c instanceof v) {
+        this.tombstones.add(c);
+        continue;
+      }
+      if (this.tombstones.hasKey(c.url)) {
+        await this.deleteChild(e, c);
+        continue;
+      }
+      await this.loadChildren(c, (o = t == null ? void 0 : t.children) == null ? void 0 : o[a]), (r = t == null ? void 0 : t.children) != null && r[a] && await this.updateProgress(() => {
+        var l;
+        return M((l = t.children) == null ? void 0 : l[a]).completed = !0;
+      });
+    }
+  }
+  async deleteChild(e, t) {
+    for (const n of e.static("relations")) {
+      const o = e.requireRelation(n);
+      if (o.related) {
+        if (Array.isArray(o.related)) {
+          o.related = o.related.filter((r) => r !== t);
+          continue;
+        }
+        if (o.related === t) {
+          o.related = null;
+          continue;
+        }
+      }
+    }
+    await t.delete();
+  }
+  async saveModelAndChildren(e, t) {
+    if (this.assertNotCancelled(), X(e) && e.isSoftDeleted()) {
+      e.enableHistory(), e.enableTombstone(), await e.delete();
+      return;
+    }
+    if (this.malformedDocuments.has(e.requireDocumentUrl()))
+      return;
+    if (await e.save(), !R(e)) {
+      if (X(e)) {
+        const r = e.requireDocumentUrl(), a = this.documentsModifiedAt[r] ?? /* @__PURE__ */ new Date();
+        await k.remember(r, a), delete this.documentsModifiedAt[r];
+      }
+      return;
+    }
+    const n = y(e.static()).map((r) => e.getRelationModels(r) ?? []).flat(), o = t ? n.map(() => ({ completed: !1 })) : [];
+    t && (t.children = o);
+    for (let r = 0; r < n.length; r++) {
+      const a = n[r], c = o[r];
+      await this.saveModelAndChildren(a, c), c && await this.updateProgress(() => c.completed = !0);
+    }
+  }
+  async synchronizeModels(e) {
+    const t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+    for (const r of e.items()) {
+      if (r instanceof v) {
+        const c = this.localModels.get(r.resourceUrl);
+        c && (await c.delete(), n.add(c));
+        continue;
+      }
+      const a = pt(r, this.localModels);
+      await this.loadChildren(a), await L.synchronize(a, r), await this.reconcileInconsistencies(a, r), await this.saveModelAndChildren(a), await this.addLocalModel(a), this.rootLocalModels.push(a), t.add(a.url);
+    }
+    for (const r of this.rootLocalModels) {
+      if (n.has(r) || t.has(r.url))
+        continue;
+      await this.loadChildren(r);
+      const a = Mt(r, e);
+      await L.synchronize(r, a), e.add(a);
+    }
+    const o = [];
+    for (const r of e.getItems()) {
+      if (De(r)) {
+        o.push(r);
+        continue;
+      }
+      await this.rememberModelDocuments(r);
+    }
+    return o;
+  }
+  async reconcileInconsistencies(e, t, n) {
+    e.rebuildAttributesFromHistory(), e.setAttributes(t.getAttributes(!0)), n ?? (n = /* @__PURE__ */ new Set()), n.add(e);
+    for (const r of y(e.static()))
+      await this.synchronizeContainerDocuments(
+        e.requireRelation(r),
+        t.requireRelation(r)
+      );
+    const o = b(G(t), "url");
+    for (const r of G(e))
+      n.has(r) || !r.isRelationLoaded("operations") || !o.hasKey(r.url) || await this.reconcileInconsistencies(r, o.require(r.url));
+    e.isDirty() && (await e.save(), await L.synchronize(e, t));
+  }
+  async synchronizeContainerDocuments(e, t) {
+    const n = b(e.related ?? [], "url"), o = b(t.related ?? [], "url"), r = n.getKeys().filter((c) => !o.hasKey(c) && !o.hasKey(encodeURI(c))), a = o.getKeys().filter((c) => !n.hasKey(c) && !n.hasKey(encodeURI(c)));
+    for (const c of r) {
+      const l = n.require(c), u = ie(l);
+      t.addRelated(u), o.add(u);
+    }
+    for (const c of a) {
+      const l = o.require(c), u = Le(l);
+      e.addRelated(u), n.add(u);
+    }
+    for (const c of n.items()) {
+      const l = o.require(c.url);
+      await L.synchronize(c, l), await this.saveModelAndChildren(c);
+    }
+  }
+  async rememberModelDocuments(e) {
+    if (!R(e)) {
+      const n = e.requireDocumentUrl(), o = this.documentsModifiedAt[n] ?? /* @__PURE__ */ new Date();
+      await k.remember(n, o), delete this.documentsModifiedAt[n];
+      return;
+    }
+    const t = y(e.static()).map((n) => e.getRelationModels(n) ?? []).flat();
+    for (const n of t)
+      await this.rememberModelDocuments(n);
+  }
+  async ignoringMalformedDocumentErrors(e) {
+    try {
+      await e();
+    } catch (t) {
+      if (S(t, Re)) {
+        console.warn(t.message), t.documentUrl && this.malformedDocuments.add(t.documentUrl);
+        return;
+      }
+      throw t;
+    }
+  }
+}
+const p = {
+  Disconnected: "disconnected",
+  Online: "online",
+  Syncing: "syncing",
+  Migrating: "migrating"
+}, qt = xe({
+  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: p.Disconnected,
+    syncError: null,
+    syncJob: null
+  }),
+  serialize: (s) => {
+    var i;
+    return oe(s, { migrationJob: (i = s.migrationJob) == null ? void 0 : i.serialize() });
+  },
+  restore: (s) => oe(s, {
+    migrationJob: s.migrationJob && N.restore(s.migrationJob)
+  }),
+  watch: {
+    migrationJob(s) {
+      s == null || s.listeners.add({ onUpdated: () => this.updatePersistedState("migrationJob") });
+    }
+  },
+  computed: {
+    disconnected: ({ status: s }) => s === p.Disconnected,
+    online: ({ status: s }) => s === p.Online,
+    syncing: ({ status: s }) => s === p.Syncing,
+    migrating: ({ status: s }) => s === p.Migrating,
+    localChanges({ localModelUpdates: s }) {
+      return Object.values(s).reduce((i, e) => i + e, 0);
+    },
+    dirty() {
+      return this.localChanges > 0;
+    },
+    migrationStarted({ migrationJob: s }) {
+      return !!s;
+    },
+    migrationDisabledReason({ status: s, ready: i }) {
+      return g.isLoggedIn() ? i ? s === p.Syncing || s === p.Migrating ? U(
+        "cloud.migrationNotSyncing",
+        "Wait for syncing to finish before starting the migration"
+      ) : this.online ? null : U(
+        "cloud.migrationNotOnline",
+        "You need to be online in order to start the migration"
+      ) : U(
+        "cloud.migrationNotReady",
+        "You need to backup your data before starting the migration"
+      ) : U(
+        "cloud.migrationNotLoggedIn",
+        "You need to reconnect before starting the migration"
+      );
+    }
+  }
+});
+class xt extends qt {
+  constructor() {
+    super(...arguments);
+    h(this, "asyncLock", new _e());
+    h(this, "engine", null);
+    h(this, "pollingInterval", null);
+  }
+  async whenReady(e) {
+    return this.ready ? e() : new Promise((t) => {
+      const n = () => t(e());
+      m.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 = Ge(e) ? { models: e } : e instanceof L ? { model: e } : e;
+    !g.isLoggedIn() || !this.ready || !this.online || await this.asyncLock.run(async () => {
+      const n = Date.now(), o = t.model ? [t.model] : t.models;
+      this.syncError = null, this.status = p.Syncing, $.clear(o);
+      try {
+        if (await m.emit("cloud:sync-started", o), t.refreshUserProfile && await g.refreshUserProfile(), this.syncJob = new Et(o), this.syncJob.listeners.add(t), await F(this.syncJob), this.syncJob.cancelled)
+          return;
+        le() || await q({ milliseconds: Math.max(500, 1e3 - (Date.now() - n)) }), this.syncJob = null;
+      } catch (r) {
+        if (le())
+          throw r;
+        this.syncJob = null, this.syncError = r, await re.report(r, U("cloud.syncFailed", "Sync failed"));
+      } finally {
+        this.status = p.Online, await m.emit("cloud:sync-completed", o);
+      }
+    });
+  }
+  shouldMigrate() {
+    return this.schemaMigrations.size > 0;
+  }
+  async migrate(e) {
+    if (!this.online || !g.isLoggedIn() || !this.ready)
+      throw new Error("Data cannot be migrated at the moment");
+    this.shouldMigrate() && await this.asyncLock.run(async () => {
+      var r;
+      this.status = p.Migrating, this.migrationJob ?? (this.migrationJob = new N());
+      const t = Date.now(), n = [], o = (r = this.migrationJob).models ?? (r.models = V());
+      $.clear(o);
+      try {
+        if (e && n.push(this.migrationJob.listeners.add(e)), await m.emit("cloud:migration-started", o), await F(this.migrationJob), this.migrationJob.cancelled) {
+          await m.emit("cloud:migration-cancelled", o);
+          return;
+        }
+        this.migrationJob = null, this.migrationDismissed = !1, this.migrationPostponed = !1, await q({ milliseconds: Math.max(0, 1e3 - (Date.now() - t)) }), await m.emit("cloud:migration-completed", o);
+      } catch (a) {
+        await re.report(a, U("cloud.migrationFailed", "Migration failed"));
+      } finally {
+        this.status = p.Online, n.forEach((a) => a == null ? void 0 : a());
+      }
+    });
+  }
+  async register(e, t = {}) {
+    if (this.registeredModels.find((o) => e === o.modelClass))
+      return;
+    const n = this.engine;
+    n && fe(e).forEach((o) => D(o).setEngine(n)), this.whenReady(() => {
+      A(e) && (e.collection = H(t.path));
+    }), await it(e, {
+      created: (o) => me(o),
+      updated: (o) => ge(o),
+      deleted: (o) => Y([o])
+    }), A(e) && y(e).forEach((o) => {
+      const r = e.instance().requireRelation(o).relatedClass;
+      r.on("created", (a) => me(a)), r.on("updated", (a) => ge(a)), r.on("deleted", (a) => Y([a]));
+    }), this.registeredModels.push({ modelClass: e, path: t.path });
+    for (const o of this.modelCollections[e.modelName] ?? [])
+      await T(e, o);
+  }
+  registerSchemaMigration(e, t) {
+    this.schemaMigrations.set(e, t);
+  }
+  requireRemoteCollection(e) {
+    for (const t of this.registeredModels)
+      if (e === t.modelClass)
+        return H(t.path);
+    throw new Error(`Failed resolving remote collection for '${e.modelName}' model`);
+  }
+  async boot() {
+    await g.booted, g.isLoggedIn() && this.login(g.authenticator), m.on("auth:login", ({ authenticator: e }) => this.login(e)), m.on("auth:logout", () => this.logout()), m.once("application-ready", () => this.onApplicationReady()), m.once("application-mounted", () => this.onApplicationMounted()), ot(() => {
+      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), t = [];
+    for (const { modelClass: n } of this.registeredModels)
+      for (const o of ne(n))
+        t.push(...this.getModelsIn(e, o));
+    return t;
+  }
+  getModelsIn(e, t) {
+    const n = [];
+    return e.includes(t.url) && n.push(t), R(t) && n.push(
+      ...Se(t).map((o) => this.getModelsIn(e, o)).flat()
+    ), n;
+  }
+  requireEngine() {
+    return this.engine ?? Me("Could not get required Engine");
+  }
+  async setReady(e) {
+    this.ready || !e || (await m.emit("cloud:ready"), this.ready = !0);
+  }
+  async backup(e) {
+    await m.emit("cloud:backup-started"), e ?? (e = /* @__PURE__ */ new WeakMap());
+    const t = new Ut();
+    for (const { modelClass: n, path: o } of this.registeredModels) {
+      if (!A(n))
+        continue;
+      for (const [c, l] of Object.entries(e.get(n) ?? {}))
+        t.migrateUrl(n, c, l);
+      const r = n.collection, a = H(o);
+      n.collection = a, t.migrateCollection(n, r, a);
+    }
+    await F(t), await m.emit("cloud:backup-completed");
+  }
+  async onApplicationReady() {
+    this.ready || !g.isLoggedIn() || await this.setReady(!V().some((e) => e.url.startsWith("solid://")));
+  }
+  async onApplicationMounted() {
+    this.syncOnStartup() && await this.sync();
+  }
+  login(e) {
+    const t = [...this.registeredModels].map(({ modelClass: n }) => fe(n)).flat().concat([v]);
+    this.status = p.Online, this.engine = e.engine;
+    for (const n of t)
+      D(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: p.Disconnected
+    });
+  }
+  syncOnStartup() {
+    return Qe("startupSync") ? Ye(Ve("startupSync")) : this.migrationJob ? !1 : this.startupSync;
+  }
+}
+const Ot = te(xt), Tt = {
+  key: 1,
+  class: "flex flex-col gap-3"
+}, Gt = /* @__PURE__ */ rt({
+  __name: "AGCloudStatus",
+  emits: ["sync"],
+  setup(s) {
+    return (i, e) => (W(), de(I(Xe), null, {
+      "logged-in": j(({ session: t }) => [
+        i.$cloud.syncing ? (W(), de(I(ae), {
+          key: 0,
+          text: i.$td("cloud.syncing", "Syncing...")
+        }, null, 8, ["text"])) : (W(), at("div", Tt, [
+          K(I(ae), {
+            text: i.$td("solid.loggedIn", "You are logged in as [{userName}]({userWebId})", {
+              userName: t.user.name ?? t.user.webId,
+              userWebId: t.user.webId
+            })
+          }, null, 8, ["text"]),
+          K(I(ce), {
+            onClick: e[0] || (e[0] = (n) => (i.$cloud.sync(), i.$emit("sync")))
+          }, {
+            default: j(() => [
+              ue(he(i.$td("cloud.sync", "Synchronize")), 1)
+            ]),
+            _: 1
+          }),
+          K(I(ce), {
+            onClick: e[1] || (e[1] = (n) => i.$solid.logout())
+          }, {
+            default: j(() => [
+              ue(he(i.$td("solid.logout", "Logout")), 1)
+            ]),
+            _: 1
+          })
+        ]))
+      ]),
+      _: 1
+    }));
+  }
+}), $t = { $cloud: Ot };
+function Qt() {
+  return {
+    name: "@aerogel/local-first",
+    async install(s) {
+      await Oe(s, {
+        ...$t,
+        $_documentsCache: k
+      });
+    }
+  };
+}
+export {
+  Gt as AGCloudStatus,
+  Ot as Cloud,
+  xt as CloudService,
+  Qt as default
+};
+//# sourceMappingURL=aerogel-plugin-local-first.js.map