1255 lines
46 KiB
JavaScript
1255 lines
46 KiB
JavaScript
var __defProp = Object.defineProperty;
|
|
var __typeError = (msg) => {
|
|
throw TypeError(msg);
|
|
};
|
|
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
|
|
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
|
|
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
|
|
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
|
|
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
|
|
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
|
|
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
|
|
var __privateWrapper = (obj, member, setter, getter) => ({
|
|
set _(value) {
|
|
__privateSet(obj, member, value, setter);
|
|
},
|
|
get _() {
|
|
return __privateGet(obj, member, getter);
|
|
}
|
|
});
|
|
import { E as D, d as P, a as q, b as K, s as G, v as V, l as x, c as T, e as J, g as k, f as Y, h as B, j as Q, k as X, m as N, n as E, C as Z, t as z, D as _, o as $, p as A, q as C, r as L, u as ee, w as j, i as te, x as R, U as y, y as M, R as v, z as W, A as se, B as re, F as ne, G as oe, H as ie, __tla as __tla_0 } from "./fullfat_bundler-C8o4MXnP.js";
|
|
let Me, Re;
|
|
let __tla = Promise.all([
|
|
(() => {
|
|
try {
|
|
return __tla_0;
|
|
} catch {
|
|
}
|
|
})()
|
|
]).then(async () => {
|
|
var _e, _s, _o, _t, _n, _r, _ae_instances, i_fn, a_fn, _e2, _s2, _o2, _t2, _n2, _e3, _s3, _o3, _t3, _n3, _le_instances, r_fn, i_fn2, a_fn2, h_fn, _e4, _s4, _o4, _t4, _n4, _r2, _i, _a, _h, _u, _me_instances, d_fn, f_fn, _l, m_fn, c_fn, p_fn, y_fn, _e5, _s5, _o5, _t5, _n5, _r3, _i2, _pe_instances, a_fn3, _e6, _s6, _o6, _Pe_instances, t_fn, _n6, _r4;
|
|
class ae extends D {
|
|
constructor() {
|
|
super(...arguments);
|
|
__privateAdd(this, _ae_instances);
|
|
__privateAdd(this, _e, /* @__PURE__ */ new Map());
|
|
__privateAdd(this, _s, /* @__PURE__ */ new Set());
|
|
__privateAdd(this, _o, /* @__PURE__ */ new Map());
|
|
__privateAdd(this, _t, /* @__PURE__ */ new Set());
|
|
__privateAdd(this, _n, /* @__PURE__ */ new Map());
|
|
__privateAdd(this, _r, P("automerge-repo:remote-heads-subscriptions"));
|
|
}
|
|
subscribeToRemotes(e) {
|
|
__privateGet(this, _r).call(this, "subscribeToRemotes", e);
|
|
const t = [];
|
|
for (const s of e) __privateGet(this, _s).has(s) || (__privateGet(this, _s).add(s), t.push(s));
|
|
t.length > 0 && this.emit("change-remote-subs", {
|
|
add: t,
|
|
peers: Array.from(__privateGet(this, _t))
|
|
});
|
|
}
|
|
unsubscribeFromRemotes(e) {
|
|
__privateGet(this, _r).call(this, "subscribeToRemotes", e);
|
|
const t = [];
|
|
for (const s of e) __privateGet(this, _s).has(s) && (__privateGet(this, _s).delete(s), __privateGet(this, _o).has(s) || t.push(s));
|
|
t.length > 0 && this.emit("change-remote-subs", {
|
|
remove: t,
|
|
peers: Array.from(__privateGet(this, _t))
|
|
});
|
|
}
|
|
handleControlMessage(e) {
|
|
const t = [], s = [], r = [];
|
|
if (__privateGet(this, _r).call(this, "handleControlMessage", e), e.add) for (const n of e.add) {
|
|
let o = __privateGet(this, _o).get(n);
|
|
(__privateGet(this, _s).has(n) || o) && r.push(n), o || (o = /* @__PURE__ */ new Set(), __privateGet(this, _o).set(n, o), __privateGet(this, _s).has(n) || t.push(n)), o.add(e.senderId);
|
|
}
|
|
if (e.remove) for (const n of e.remove) {
|
|
const o = __privateGet(this, _o).get(n);
|
|
o && (o.delete(e.senderId), o.size == 0 && !__privateGet(this, _s).has(n) && s.push(n));
|
|
}
|
|
(t.length > 0 || s.length > 0) && this.emit("change-remote-subs", {
|
|
peers: Array.from(__privateGet(this, _t)),
|
|
add: t,
|
|
remove: s
|
|
});
|
|
for (const n of r) {
|
|
const o = __privateGet(this, _n).get(e.senderId);
|
|
if (o) for (const a of o) {
|
|
const u = __privateGet(this, _e).get(a);
|
|
if (!u) continue;
|
|
const h = u.get(n);
|
|
h && this.emit("notify-remote-heads", {
|
|
targetId: e.senderId,
|
|
documentId: a,
|
|
heads: h.lastHeads,
|
|
timestamp: h.lastSyncTimestamp,
|
|
storageId: n
|
|
});
|
|
}
|
|
}
|
|
}
|
|
handleRemoteHeads(e) {
|
|
__privateGet(this, _r).call(this, "handleRemoteHeads", e);
|
|
const t = __privateMethod(this, _ae_instances, a_fn).call(this, e);
|
|
for (const s of t) __privateGet(this, _s).has(s.storageId) && this.emit("remote-heads-changed", s);
|
|
for (const s of t) for (const r of __privateGet(this, _t)) r !== e.senderId && this.emit("notify-remote-heads", {
|
|
targetId: r,
|
|
documentId: s.documentId,
|
|
heads: s.remoteHeads,
|
|
timestamp: s.timestamp,
|
|
storageId: s.storageId
|
|
});
|
|
for (const s of t) {
|
|
const r = __privateGet(this, _o).get(s.storageId);
|
|
if (r) for (const n of r) __privateMethod(this, _ae_instances, i_fn).call(this, n, s.documentId) && this.emit("notify-remote-heads", {
|
|
targetId: n,
|
|
documentId: s.documentId,
|
|
heads: s.remoteHeads,
|
|
timestamp: s.timestamp,
|
|
storageId: s.storageId
|
|
});
|
|
}
|
|
}
|
|
handleImmediateRemoteHeadsChanged(e, t, s) {
|
|
__privateGet(this, _r).call(this, "handleLocalHeadsChanged", e, t, s);
|
|
const r = __privateGet(this, _e).get(e), n = Date.now();
|
|
if (!r) __privateGet(this, _e).set(e, /* @__PURE__ */ new Map([
|
|
[
|
|
t,
|
|
{
|
|
lastSyncTimestamp: n,
|
|
lastHeads: s
|
|
}
|
|
]
|
|
]));
|
|
else {
|
|
const a = r.get(t);
|
|
(!a || a.lastSyncTimestamp < Date.now()) && r.set(t, {
|
|
lastSyncTimestamp: Date.now(),
|
|
lastHeads: s
|
|
});
|
|
}
|
|
const o = __privateGet(this, _o).get(t);
|
|
if (o) for (const a of o) __privateMethod(this, _ae_instances, i_fn).call(this, a, e) && this.emit("notify-remote-heads", {
|
|
targetId: a,
|
|
documentId: e,
|
|
heads: s,
|
|
timestamp: n,
|
|
storageId: t
|
|
});
|
|
}
|
|
addGenerousPeer(e) {
|
|
__privateGet(this, _r).call(this, "addGenerousPeer", e), __privateGet(this, _t).add(e), __privateGet(this, _s).size > 0 && this.emit("change-remote-subs", {
|
|
add: Array.from(__privateGet(this, _s)),
|
|
peers: [
|
|
e
|
|
]
|
|
});
|
|
for (const [t, s] of __privateGet(this, _e)) for (const [r, { lastHeads: n, lastSyncTimestamp: o }] of s) this.emit("notify-remote-heads", {
|
|
targetId: e,
|
|
documentId: t,
|
|
heads: n,
|
|
timestamp: o,
|
|
storageId: r
|
|
});
|
|
}
|
|
removePeer(e) {
|
|
__privateGet(this, _r).call(this, "removePeer", e);
|
|
const t = [];
|
|
__privateGet(this, _t).delete(e), __privateGet(this, _n).delete(e);
|
|
for (const [s, r] of __privateGet(this, _o)) r.has(e) && (r.delete(e), r.size == 0 && (t.push(s), __privateGet(this, _o).delete(s)));
|
|
t.length > 0 && this.emit("change-remote-subs", {
|
|
remove: t,
|
|
peers: Array.from(__privateGet(this, _t))
|
|
});
|
|
}
|
|
subscribePeerToDoc(e, t) {
|
|
let s = __privateGet(this, _n).get(e);
|
|
s || (s = /* @__PURE__ */ new Set(), __privateGet(this, _n).set(e, s)), s.add(t);
|
|
const r = __privateGet(this, _e).get(t);
|
|
if (r) for (const [n, o] of r) {
|
|
const a = __privateGet(this, _o).get(n);
|
|
a && a.has(e) && this.emit("notify-remote-heads", {
|
|
targetId: e,
|
|
documentId: t,
|
|
heads: o.lastHeads,
|
|
timestamp: o.lastSyncTimestamp,
|
|
storageId: n
|
|
});
|
|
}
|
|
}
|
|
}
|
|
_e = new WeakMap();
|
|
_s = new WeakMap();
|
|
_o = new WeakMap();
|
|
_t = new WeakMap();
|
|
_n = new WeakMap();
|
|
_r = new WeakMap();
|
|
_ae_instances = new WeakSet();
|
|
i_fn = function(e, t) {
|
|
const s = __privateGet(this, _n).get(e);
|
|
return s && s.has(t);
|
|
};
|
|
a_fn = function(e) {
|
|
const t = [], { documentId: s, newHeads: r } = e;
|
|
for (const [n, { heads: o, timestamp: a }] of Object.entries(r)) {
|
|
if (!__privateGet(this, _s).has(n) && !__privateGet(this, _o).has(n)) continue;
|
|
let u = __privateGet(this, _e).get(s);
|
|
u || (u = /* @__PURE__ */ new Map(), __privateGet(this, _e).set(s, u));
|
|
const h = u.get(n);
|
|
h && h.lastSyncTimestamp >= a || (u.set(n, {
|
|
lastSyncTimestamp: a,
|
|
lastHeads: o
|
|
}), t.push({
|
|
documentId: s,
|
|
storageId: n,
|
|
remoteHeads: o,
|
|
timestamp: a
|
|
}));
|
|
}
|
|
return t;
|
|
};
|
|
const ce = (d) => `${d.senderId}:${d.sessionId}`;
|
|
class he extends D {
|
|
constructor(e, t, s) {
|
|
super();
|
|
__publicField(this, "peerId");
|
|
__publicField(this, "peerMetadata");
|
|
__privateAdd(this, _e2);
|
|
__privateAdd(this, _s2, {});
|
|
__privateAdd(this, _o2, 0);
|
|
__privateAdd(this, _t2, Math.random().toString(36).slice(2));
|
|
__privateAdd(this, _n2, {});
|
|
__publicField(this, "adapters", []);
|
|
__publicField(this, "isReady", () => this.adapters.every((e) => e.isReady()));
|
|
__publicField(this, "whenReady", async () => Promise.all(this.adapters.map((e) => e.whenReady())));
|
|
this.peerId = t, this.peerMetadata = s, __privateSet(this, _e2, P(`automerge-repo:network:${this.peerId}`)), e.forEach((r) => this.addNetworkAdapter(r));
|
|
}
|
|
disconnect() {
|
|
this.adapters.forEach((e) => e.disconnect());
|
|
}
|
|
reconnect() {
|
|
this.adapters.forEach((e) => e.connect(this.peerId));
|
|
}
|
|
addNetworkAdapter(e) {
|
|
this.adapters.push(e), e.on("peer-candidate", ({ peerId: t, peerMetadata: s }) => {
|
|
__privateGet(this, _e2).call(this, `peer candidate: ${t} `), __privateGet(this, _s2)[t] || (__privateGet(this, _s2)[t] = e), this.emit("peer", {
|
|
peerId: t,
|
|
peerMetadata: s
|
|
});
|
|
}), e.on("peer-disconnected", ({ peerId: t }) => {
|
|
__privateGet(this, _e2).call(this, `peer disconnected: ${t} `), delete __privateGet(this, _s2)[t], this.emit("peer-disconnected", {
|
|
peerId: t
|
|
});
|
|
}), e.on("message", (t) => {
|
|
if (!q(t)) {
|
|
__privateGet(this, _e2).call(this, `invalid message: ${JSON.stringify(t)}`);
|
|
return;
|
|
}
|
|
if (__privateGet(this, _e2).call(this, `message from ${t.senderId}`), K(t)) {
|
|
const s = ce(t);
|
|
(__privateGet(this, _n2)[s] === void 0 || t.count > __privateGet(this, _n2)[s]) && (__privateGet(this, _n2)[s] = t.count, this.emit("message", t));
|
|
return;
|
|
}
|
|
this.emit("message", t);
|
|
}), e.on("close", () => {
|
|
__privateGet(this, _e2).call(this, "adapter closed"), Object.entries(__privateGet(this, _s2)).forEach(([t, s]) => {
|
|
s === e && delete __privateGet(this, _s2)[t];
|
|
}), this.adapters = this.adapters.filter((t) => t !== e);
|
|
}), this.peerMetadata.then((t) => {
|
|
e.connect(this.peerId, t);
|
|
}).catch((t) => {
|
|
__privateGet(this, _e2).call(this, "error connecting to network", t);
|
|
});
|
|
}
|
|
removeNetworkAdapter(e) {
|
|
this.adapters = this.adapters.filter((t) => t !== e), e.disconnect();
|
|
}
|
|
send(e) {
|
|
const t = __privateGet(this, _s2)[e.targetId];
|
|
if (!t) {
|
|
__privateGet(this, _e2).call(this, `Tried to send message but peer not found: ${e.targetId}`);
|
|
return;
|
|
}
|
|
const r = ((n) => n.type === "ephemeral" ? "count" in n ? n : {
|
|
...n,
|
|
count: ++__privateWrapper(this, _o2)._,
|
|
sessionId: __privateGet(this, _t2),
|
|
senderId: this.peerId
|
|
} : {
|
|
...n,
|
|
senderId: this.peerId
|
|
})(e);
|
|
__privateGet(this, _e2).call(this, "sending message %o", r), t.send(r);
|
|
}
|
|
}
|
|
_e2 = new WeakMap();
|
|
_s2 = new WeakMap();
|
|
_o2 = new WeakMap();
|
|
_t2 = new WeakMap();
|
|
_n2 = new WeakMap();
|
|
function O(d) {
|
|
let e = 0;
|
|
d.forEach((r) => {
|
|
e += r.length;
|
|
});
|
|
const t = new Uint8Array(e);
|
|
let s = 0;
|
|
return d.forEach((r) => {
|
|
t.set(r, s), s += r.length;
|
|
}), t;
|
|
}
|
|
function F(d) {
|
|
const e = G.hash(d);
|
|
return ue(e);
|
|
}
|
|
function de(d) {
|
|
const e = new TextEncoder(), t = O(d.map((s) => e.encode(s)));
|
|
return F(t);
|
|
}
|
|
function ue(d) {
|
|
return Array.from(d, (e) => e.toString(16).padStart(2, "0")).join("");
|
|
}
|
|
class le extends D {
|
|
constructor(e) {
|
|
super();
|
|
__privateAdd(this, _le_instances);
|
|
__privateAdd(this, _e3);
|
|
__privateAdd(this, _s3, /* @__PURE__ */ new Map());
|
|
__privateAdd(this, _o3, /* @__PURE__ */ new Map());
|
|
__privateAdd(this, _t3, false);
|
|
__privateAdd(this, _n3, P("automerge-repo:storage-subsystem"));
|
|
__privateSet(this, _e3, e);
|
|
}
|
|
async id() {
|
|
const e = await __privateGet(this, _e3).load([
|
|
"storage-adapter-id"
|
|
]);
|
|
let t;
|
|
return e ? t = new TextDecoder().decode(e) : (t = V(), await __privateGet(this, _e3).save([
|
|
"storage-adapter-id"
|
|
], new TextEncoder().encode(t))), t;
|
|
}
|
|
async load(e, t) {
|
|
const s = [
|
|
e,
|
|
t
|
|
];
|
|
return await __privateGet(this, _e3).load(s);
|
|
}
|
|
async save(e, t, s) {
|
|
const r = [
|
|
e,
|
|
t
|
|
];
|
|
await __privateGet(this, _e3).save(r, s);
|
|
}
|
|
async remove(e, t) {
|
|
const s = [
|
|
e,
|
|
t
|
|
];
|
|
await __privateGet(this, _e3).remove(s);
|
|
}
|
|
async loadDocData(e) {
|
|
const t = await __privateGet(this, _e3).loadRange([
|
|
e,
|
|
"snapshot"
|
|
]), s = await __privateGet(this, _e3).loadRange([
|
|
e,
|
|
"incremental"
|
|
]), r = [], n = [];
|
|
for (const o of t) o.data !== void 0 && (n.push({
|
|
key: o.key,
|
|
type: "snapshot",
|
|
size: o.data.length
|
|
}), r.push(o.data));
|
|
for (const o of s) o.data !== void 0 && (n.push({
|
|
key: o.key,
|
|
type: "incremental",
|
|
size: o.data.length
|
|
}), r.push(o.data));
|
|
return __privateGet(this, _o3).set(e, n), r.length === 0 ? null : O(r);
|
|
}
|
|
async loadDoc(e) {
|
|
const t = await this.loadDocData(e);
|
|
if (!t) return null;
|
|
const s = performance.now(), r = x(T(), t), n = performance.now();
|
|
return this.emit("document-loaded", {
|
|
documentId: e,
|
|
durationMillis: n - s,
|
|
...J(r)
|
|
}), __privateGet(this, _s3).set(e, k(r)), r;
|
|
}
|
|
async saveDoc(e, t) {
|
|
if (!__privateMethod(this, _le_instances, a_fn2).call(this, e, t)) return;
|
|
const s = __privateGet(this, _o3).get(e) ?? [];
|
|
__privateMethod(this, _le_instances, h_fn).call(this, s) ? await __privateMethod(this, _le_instances, i_fn2).call(this, e, t, s) : await __privateMethod(this, _le_instances, r_fn).call(this, e, t), __privateGet(this, _s3).set(e, k(t));
|
|
}
|
|
async removeDoc(e) {
|
|
await __privateGet(this, _e3).removeRange([
|
|
e,
|
|
"snapshot"
|
|
]), await __privateGet(this, _e3).removeRange([
|
|
e,
|
|
"incremental"
|
|
]), await __privateGet(this, _e3).removeRange([
|
|
e,
|
|
"sync-state"
|
|
]);
|
|
}
|
|
async loadSyncState(e, t) {
|
|
const s = [
|
|
e,
|
|
"sync-state",
|
|
t
|
|
];
|
|
try {
|
|
const r = await __privateGet(this, _e3).load(s);
|
|
return r ? Q(r) : void 0;
|
|
} catch {
|
|
__privateGet(this, _n3).call(this, `Error loading sync state for ${e} from ${t}`);
|
|
return;
|
|
}
|
|
}
|
|
async saveSyncState(e, t, s) {
|
|
const r = [
|
|
e,
|
|
"sync-state",
|
|
t
|
|
];
|
|
await __privateGet(this, _e3).save(r, X(s));
|
|
}
|
|
}
|
|
_e3 = new WeakMap();
|
|
_s3 = new WeakMap();
|
|
_o3 = new WeakMap();
|
|
_t3 = new WeakMap();
|
|
_n3 = new WeakMap();
|
|
_le_instances = new WeakSet();
|
|
r_fn = async function(e, t) {
|
|
const s = __privateGet(this, _s3).get(e) ?? [], r = performance.now(), n = Y(t, s), o = performance.now();
|
|
if (this.emit("doc-saved", {
|
|
documentId: e,
|
|
durationMillis: o - r,
|
|
sinceHeads: s
|
|
}), n && n.length > 0) {
|
|
const a = [
|
|
e,
|
|
"incremental",
|
|
F(n)
|
|
];
|
|
__privateGet(this, _n3).call(this, `Saving incremental ${a} for document ${e}`), await __privateGet(this, _e3).save(a, n), __privateGet(this, _o3).has(e) || __privateGet(this, _o3).set(e, []), __privateGet(this, _o3).get(e).push({
|
|
key: a,
|
|
type: "incremental",
|
|
size: n.length
|
|
}), __privateGet(this, _s3).set(e, k(t));
|
|
} else return Promise.resolve();
|
|
};
|
|
i_fn2 = async function(e, t, s) {
|
|
var _a2;
|
|
__privateSet(this, _t3, true);
|
|
const r = performance.now(), n = B(t), o = performance.now();
|
|
this.emit("doc-compacted", {
|
|
documentId: e,
|
|
durationMillis: o - r
|
|
});
|
|
const a = de(k(t)), u = [
|
|
e,
|
|
"snapshot",
|
|
a
|
|
], h = new Set(s.map((c) => c.key).filter((c) => c[2] !== a));
|
|
__privateGet(this, _n3).call(this, `Saving snapshot ${u} for document ${e}`), __privateGet(this, _n3).call(this, `deleting old chunks ${Array.from(h)}`), await __privateGet(this, _e3).save(u, n);
|
|
for (const c of h) await __privateGet(this, _e3).remove(c);
|
|
const p = ((_a2 = __privateGet(this, _o3).get(e)) == null ? void 0 : _a2.filter((c) => !h.has(c.key))) ?? [];
|
|
p.push({
|
|
key: u,
|
|
type: "snapshot",
|
|
size: n.length
|
|
}), __privateGet(this, _o3).set(e, p), __privateSet(this, _t3, false);
|
|
};
|
|
a_fn2 = function(e, t) {
|
|
const s = __privateGet(this, _s3).get(e);
|
|
if (!s) return true;
|
|
const r = k(t);
|
|
return !N(E(r), E(s));
|
|
};
|
|
h_fn = function(e) {
|
|
if (__privateGet(this, _t3)) return false;
|
|
let t = 0, s = 0;
|
|
for (const r of e) r.type === "snapshot" ? t += r.size : s += r.size;
|
|
return t < 1024 || s >= t;
|
|
};
|
|
function fe() {
|
|
return "peer-" + Math.random().toString(36).slice(4);
|
|
}
|
|
class me extends D {
|
|
constructor({ storage: e, network: t = [], peerId: s = fe(), sharePolicy: r, shareConfig: n, isEphemeral: o = e === void 0, enableRemoteHeadsGossiping: a = false, denylist: u = [], saveDebounceRate: h = 100, idFactory: p } = {}) {
|
|
super();
|
|
__privateAdd(this, _me_instances);
|
|
__privateAdd(this, _e4);
|
|
__publicField(this, "networkSubsystem");
|
|
__publicField(this, "storageSubsystem");
|
|
__privateAdd(this, _s4);
|
|
__privateAdd(this, _o4);
|
|
__privateAdd(this, _t4, {});
|
|
__publicField(this, "synchronizer");
|
|
__privateAdd(this, _n4, {
|
|
announce: async () => true,
|
|
access: async () => true
|
|
});
|
|
__publicField(this, "peerMetadataByPeerId", {});
|
|
__privateAdd(this, _r2, new ae());
|
|
__privateAdd(this, _i, false);
|
|
__privateAdd(this, _a, {});
|
|
__privateAdd(this, _h, {});
|
|
__privateAdd(this, _u);
|
|
__privateAdd(this, _l, {});
|
|
__publicField(this, "subscribeToRemotes", (e) => {
|
|
__privateGet(this, _i) ? (__privateGet(this, _e4).call(this, "subscribeToRemotes", {
|
|
remotes: e
|
|
}), __privateGet(this, _r2).subscribeToRemotes(e)) : __privateGet(this, _e4).call(this, "WARN: subscribeToRemotes called but remote heads gossiping is not enabled");
|
|
});
|
|
__publicField(this, "storageId", async () => {
|
|
if (this.storageSubsystem) return this.storageSubsystem.id();
|
|
});
|
|
if (__privateSet(this, _i, a), __privateSet(this, _e4, P("automerge-repo:repo")), __privateSet(this, _u, p || null), r != null && n != null) throw new Error("cannot provide both sharePolicy and shareConfig at once");
|
|
r && __privateSet(this, _n4, {
|
|
announce: r,
|
|
access: async () => true
|
|
}), n && __privateSet(this, _n4, n), this.on("delete-document", ({ documentId: i }) => {
|
|
this.synchronizer.removeDocument(i), c && c.removeDoc(i).catch((f) => {
|
|
__privateGet(this, _e4).call(this, "error deleting document", {
|
|
documentId: i,
|
|
err: f
|
|
});
|
|
});
|
|
}), this.synchronizer = new Z(this, u), this.synchronizer.on("message", (i) => {
|
|
__privateGet(this, _e4).call(this, `sending ${i.type} message to ${i.targetId}`), m.send(i);
|
|
}), this.synchronizer.on("metrics", (i) => this.emit("doc-metrics", i)), __privateGet(this, _i) && this.synchronizer.on("open-doc", ({ peerId: i, documentId: f }) => {
|
|
__privateGet(this, _r2).subscribePeerToDoc(i, f);
|
|
});
|
|
const c = e ? new le(e) : void 0;
|
|
c && (c.on("document-loaded", (i) => this.emit("doc-metrics", {
|
|
type: "doc-loaded",
|
|
...i
|
|
})), c.on("doc-compacted", (i) => this.emit("doc-metrics", {
|
|
type: "doc-compacted",
|
|
...i
|
|
})), c.on("doc-saved", (i) => this.emit("doc-metrics", {
|
|
type: "doc-saved",
|
|
...i
|
|
}))), this.storageSubsystem = c, __privateSet(this, _s4, h), this.storageSubsystem ? __privateSet(this, _o4, ({ handle: i, doc: f }) => {
|
|
let l = __privateGet(this, _h)[i.documentId];
|
|
l || (l = z(({ doc: I, handle: H }) => {
|
|
this.storageSubsystem.saveDoc(H.documentId, I);
|
|
}, __privateGet(this, _s4)), __privateGet(this, _h)[i.documentId] = l), l({
|
|
handle: i,
|
|
doc: f
|
|
});
|
|
}) : __privateSet(this, _o4, () => {
|
|
});
|
|
const b = (async () => ({
|
|
storageId: await (c == null ? void 0 : c.id()),
|
|
isEphemeral: o
|
|
}))(), m = new he(t, s, b);
|
|
this.networkSubsystem = m, m.on("peer", async ({ peerId: i, peerMetadata: f }) => {
|
|
__privateGet(this, _e4).call(this, "peer connected", {
|
|
peerId: i
|
|
}), f && (this.peerMetadataByPeerId[i] = {
|
|
...f
|
|
}), __privateGet(this, _n4).announce(i).then((l) => {
|
|
l && __privateGet(this, _i) && __privateGet(this, _r2).addGenerousPeer(i);
|
|
}).catch((l) => {
|
|
console.log("error in share policy", {
|
|
err: l
|
|
});
|
|
}), this.synchronizer.addPeer(i);
|
|
}), m.on("peer-disconnected", ({ peerId: i }) => {
|
|
this.synchronizer.removePeer(i), __privateGet(this, _r2).removePeer(i);
|
|
}), m.on("message", async (i) => {
|
|
__privateMethod(this, _me_instances, f_fn).call(this, i);
|
|
}), this.synchronizer.on("sync-state", (i) => {
|
|
var _a2;
|
|
__privateMethod(this, _me_instances, m_fn).call(this, i);
|
|
const f = __privateGet(this, _t4)[i.documentId], { storageId: l } = this.peerMetadataByPeerId[i.peerId] || {};
|
|
if (!l) return;
|
|
const I = (_a2 = f.getSyncInfo(l)) == null ? void 0 : _a2.lastHeads;
|
|
i.syncState.theirHeads && (!I || !N(I, E(i.syncState.theirHeads))) && i.syncState.theirHeads && (f.setSyncInfo(l, {
|
|
lastHeads: E(i.syncState.theirHeads),
|
|
lastSyncTimestamp: Date.now()
|
|
}), l && __privateGet(this, _i) && __privateGet(this, _r2).handleImmediateRemoteHeadsChanged(i.documentId, l, E(i.syncState.theirHeads)));
|
|
}), __privateGet(this, _i) && (__privateGet(this, _r2).on("notify-remote-heads", (i) => {
|
|
this.networkSubsystem.send({
|
|
type: "remote-heads-changed",
|
|
targetId: i.targetId,
|
|
documentId: i.documentId,
|
|
newHeads: {
|
|
[i.storageId]: {
|
|
heads: i.heads,
|
|
timestamp: i.timestamp
|
|
}
|
|
}
|
|
});
|
|
}), __privateGet(this, _r2).on("change-remote-subs", (i) => {
|
|
__privateGet(this, _e4).call(this, "change-remote-subs", i);
|
|
for (const f of i.peers) this.networkSubsystem.send({
|
|
type: "remote-subscription-change",
|
|
targetId: f,
|
|
add: i.add,
|
|
remove: i.remove
|
|
});
|
|
}), __privateGet(this, _r2).on("remote-heads-changed", ({ documentId: i, storageId: f, remoteHeads: l, timestamp: I }) => {
|
|
__privateGet(this, _t4)[i].setSyncInfo(f, {
|
|
lastHeads: l,
|
|
lastSyncTimestamp: I
|
|
});
|
|
}));
|
|
}
|
|
get handles() {
|
|
return __privateGet(this, _t4);
|
|
}
|
|
get peers() {
|
|
return this.synchronizer.peers;
|
|
}
|
|
get peerId() {
|
|
return this.networkSubsystem.peerId;
|
|
}
|
|
get sharePolicy() {
|
|
return __privateGet(this, _n4).announce;
|
|
}
|
|
set sharePolicy(e) {
|
|
__privateGet(this, _n4).announce = e;
|
|
}
|
|
get shareConfig() {
|
|
return __privateGet(this, _n4);
|
|
}
|
|
set shareConfig(e) {
|
|
__privateSet(this, _n4, e);
|
|
}
|
|
getStorageIdOfPeer(e) {
|
|
var _a2;
|
|
return (_a2 = this.peerMetadataByPeerId[e]) == null ? void 0 : _a2.storageId;
|
|
}
|
|
create(e) {
|
|
let t;
|
|
e ? t = $(e) : t = A(T());
|
|
const { documentId: s } = C(L()), r = __privateMethod(this, _me_instances, c_fn).call(this, {
|
|
documentId: s
|
|
});
|
|
return __privateMethod(this, _me_instances, d_fn).call(this, r), r.update(() => t), r.doneLoading(), r;
|
|
}
|
|
async create2(e) {
|
|
let t;
|
|
e ? t = $(e) : t = A(T());
|
|
let { documentId: s } = C(L());
|
|
if (__privateGet(this, _u)) {
|
|
const n = await __privateGet(this, _u).call(this, k(t));
|
|
s = ee(n);
|
|
}
|
|
const r = __privateMethod(this, _me_instances, c_fn).call(this, {
|
|
documentId: s
|
|
});
|
|
return __privateMethod(this, _me_instances, d_fn).call(this, r), r.update(() => t), r.doneLoading(), r;
|
|
}
|
|
clone(e) {
|
|
if (!e.isReady()) throw new Error(`Cloned handle is not yet in ready state.
|
|
(Try await handle.whenReady() first.)`);
|
|
const t = e.doc(), s = this.create();
|
|
return s.update(() => j(t)), s;
|
|
}
|
|
findWithProgress(e, t = {}) {
|
|
const { signal: s } = t, { documentId: r, heads: n } = te(e) ? C(e) : {
|
|
documentId: R(e),
|
|
heads: void 0
|
|
};
|
|
if (__privateGet(this, _t4)[r]) {
|
|
const c = __privateGet(this, _t4)[r];
|
|
if (c.state === y) return {
|
|
state: "unavailable",
|
|
error: new Error(`Document ${e} is unavailable`),
|
|
handle: c
|
|
};
|
|
if (c.state === M) return {
|
|
state: "failed",
|
|
error: new Error(`Document ${e} was deleted`),
|
|
handle: c
|
|
};
|
|
if (c.state === v) return {
|
|
state: "ready",
|
|
handle: n ? c.view(n) : c
|
|
};
|
|
}
|
|
const o = __privateGet(this, _a)[r];
|
|
if (o) {
|
|
const c = __privateGet(this, _t4)[r];
|
|
if (c && (c.state === v || c.state === y || c.state === M || c.state === "loading")) return o;
|
|
}
|
|
const a = __privateMethod(this, _me_instances, c_fn).call(this, {
|
|
documentId: r
|
|
}), u = {
|
|
state: "loading",
|
|
progress: 0,
|
|
handle: a
|
|
}, h = {
|
|
subscribers: /* @__PURE__ */ new Set(),
|
|
currentProgress: void 0,
|
|
notify: (c) => {
|
|
h.currentProgress = c, h.subscribers.forEach((b) => b(c)), __privateGet(this, _a)[r] = c;
|
|
},
|
|
peek: () => h.currentProgress || u,
|
|
subscribe: (c) => (h.subscribers.add(c), () => h.subscribers.delete(c))
|
|
};
|
|
h.notify(u), __privateMethod(this, _me_instances, p_fn).call(this, e, r, a, h, s ? W(new Promise(() => {
|
|
}), s) : new Promise(() => {
|
|
}));
|
|
const p = {
|
|
...u,
|
|
peek: h.peek,
|
|
subscribe: h.subscribe
|
|
};
|
|
return __privateGet(this, _a)[r] = p, p;
|
|
}
|
|
async find(e, t = {}) {
|
|
const { allowableStates: s = [
|
|
"ready"
|
|
], signal: r } = t;
|
|
if (r == null ? void 0 : r.aborted) throw new se();
|
|
const n = this.findWithProgress(e, {
|
|
signal: r
|
|
});
|
|
if ("subscribe" in n) return __privateMethod(this, _me_instances, d_fn).call(this, n.handle), new Promise((o, a) => {
|
|
const u = n.subscribe((h) => {
|
|
s.includes(h.handle.state) ? (u(), o(h.handle)) : h.state === "unavailable" ? (u(), a(new Error(`Document ${e} is unavailable`))) : h.state === "failed" && (u(), a(h.error));
|
|
});
|
|
});
|
|
if (n.handle.state === v) return n.handle;
|
|
if (await n.handle.whenReady([
|
|
v,
|
|
y
|
|
]), n.handle.state === "unavailable" && !s.includes(y)) throw new Error(`Document ${e} is unavailable`);
|
|
return n.handle;
|
|
}
|
|
async findClassic(e, t = {}) {
|
|
const s = R(e), { allowableStates: r, signal: n } = t;
|
|
return W((async () => {
|
|
const o = await __privateMethod(this, _me_instances, y_fn).call(this, s);
|
|
if (!r && (await o.whenReady([
|
|
v,
|
|
y
|
|
]), o.state === y && !(n == null ? void 0 : n.aborted))) throw new Error(`Document ${e} is unavailable`);
|
|
return o;
|
|
})(), n);
|
|
}
|
|
delete(e) {
|
|
const t = R(e);
|
|
__privateMethod(this, _me_instances, c_fn).call(this, {
|
|
documentId: t
|
|
}).delete(), delete __privateGet(this, _t4)[t], delete __privateGet(this, _a)[t], delete __privateGet(this, _h)[t], this.emit("delete-document", {
|
|
documentId: t
|
|
});
|
|
}
|
|
async export(e) {
|
|
const t = R(e), r = (await this.find(t)).doc();
|
|
return B(r);
|
|
}
|
|
import(e, t) {
|
|
const s = t == null ? void 0 : t.docId;
|
|
if (s != null) {
|
|
const r = __privateMethod(this, _me_instances, c_fn).call(this, {
|
|
documentId: s
|
|
});
|
|
return r.update((n) => x(n, e)), __privateMethod(this, _me_instances, d_fn).call(this, r), r;
|
|
} else {
|
|
const r = re(e), n = this.create();
|
|
return n.update(() => j(r)), n;
|
|
}
|
|
}
|
|
async flush(e) {
|
|
if (!this.storageSubsystem) return;
|
|
const t = e ? e.map((s) => __privateGet(this, _t4)[s]) : Object.values(__privateGet(this, _t4));
|
|
await Promise.all(t.map(async (s) => this.storageSubsystem.saveDoc(s.documentId, s.doc())));
|
|
}
|
|
async removeFromCache(e) {
|
|
if (!__privateGet(this, _t4)[e]) {
|
|
__privateGet(this, _e4).call(this, `WARN: removeFromCache called but handle not found in handleCache for documentId: ${e}`);
|
|
return;
|
|
}
|
|
const t = __privateMethod(this, _me_instances, c_fn).call(this, {
|
|
documentId: e
|
|
});
|
|
await t.whenReady([
|
|
v,
|
|
ne,
|
|
M,
|
|
y
|
|
]), t.doc() ? (t.isReady() ? t.unload() : __privateGet(this, _e4).call(this, `WARN: removeFromCache called but handle for documentId: ${e} in unexpected state: ${t.state}`), delete __privateGet(this, _t4)[e], delete __privateGet(this, _a)[e], delete __privateGet(this, _h)[e], this.synchronizer.removeDocument(e)) : __privateGet(this, _e4).call(this, `WARN: removeFromCache called but doc undefined for documentId: ${e}`);
|
|
}
|
|
shutdown() {
|
|
return this.networkSubsystem.adapters.forEach((e) => {
|
|
e.disconnect();
|
|
}), this.flush();
|
|
}
|
|
metrics() {
|
|
return {
|
|
documents: this.synchronizer.metrics()
|
|
};
|
|
}
|
|
shareConfigChanged() {
|
|
this.synchronizer.reevaluateDocumentShare();
|
|
}
|
|
}
|
|
_e4 = new WeakMap();
|
|
_s4 = new WeakMap();
|
|
_o4 = new WeakMap();
|
|
_t4 = new WeakMap();
|
|
_n4 = new WeakMap();
|
|
_r2 = new WeakMap();
|
|
_i = new WeakMap();
|
|
_a = new WeakMap();
|
|
_h = new WeakMap();
|
|
_u = new WeakMap();
|
|
_me_instances = new WeakSet();
|
|
d_fn = function(e) {
|
|
this.storageSubsystem && (e.listeners("heads-changed").some((s) => s === __privateGet(this, _o4)) || e.on("heads-changed", __privateGet(this, _o4))), this.synchronizer.addDocument(e);
|
|
};
|
|
f_fn = function(e) {
|
|
switch (e.type) {
|
|
case "remote-subscription-change":
|
|
__privateGet(this, _i) && __privateGet(this, _r2).handleControlMessage(e);
|
|
break;
|
|
case "remote-heads-changed":
|
|
__privateGet(this, _i) && __privateGet(this, _r2).handleRemoteHeads(e);
|
|
break;
|
|
case "sync":
|
|
case "request":
|
|
case "ephemeral":
|
|
case "doc-unavailable":
|
|
this.synchronizer.receiveMessage(e).catch((t) => {
|
|
console.log("error receiving message", {
|
|
err: t,
|
|
message: e
|
|
});
|
|
});
|
|
}
|
|
};
|
|
_l = new WeakMap();
|
|
m_fn = function(e) {
|
|
if (!this.storageSubsystem) return;
|
|
const { storageId: t, isEphemeral: s } = this.peerMetadataByPeerId[e.peerId] || {};
|
|
if (!t || s) return;
|
|
let r = __privateGet(this, _l)[t];
|
|
r || (r = __privateGet(this, _l)[t] = z(({ documentId: n, syncState: o }) => {
|
|
this.storageSubsystem.saveSyncState(n, t, o);
|
|
}, __privateGet(this, _s4))), r(e);
|
|
};
|
|
c_fn = function({ documentId: e }) {
|
|
if (__privateGet(this, _t4)[e]) return __privateGet(this, _t4)[e];
|
|
if (!e) throw new Error(`Invalid documentId ${e}`);
|
|
const t = new _(e);
|
|
return __privateGet(this, _t4)[e] = t, t;
|
|
};
|
|
p_fn = async function(e, t, s, r, n) {
|
|
try {
|
|
r.notify({
|
|
state: "loading",
|
|
progress: 25,
|
|
handle: s
|
|
});
|
|
const o = await (this.storageSubsystem ? this.storageSubsystem.loadDoc(s.documentId) : Promise.resolve(null)), a = await Promise.race([
|
|
o,
|
|
n
|
|
]);
|
|
if (a ? (s.update(() => a), s.doneLoading(), r.notify({
|
|
state: "loading",
|
|
progress: 50,
|
|
handle: s
|
|
})) : (await Promise.race([
|
|
this.networkSubsystem.whenReady(),
|
|
n
|
|
]), s.request(), r.notify({
|
|
state: "loading",
|
|
progress: 75,
|
|
handle: s
|
|
})), __privateMethod(this, _me_instances, d_fn).call(this, s), await Promise.race([
|
|
s.whenReady([
|
|
v,
|
|
y
|
|
]),
|
|
n
|
|
]), s.state === y) {
|
|
const u = {
|
|
state: "unavailable",
|
|
handle: s
|
|
};
|
|
r.notify(u);
|
|
return;
|
|
}
|
|
if (s.state === M) throw new Error(`Document ${e} was deleted`);
|
|
r.notify({
|
|
state: "ready",
|
|
handle: s
|
|
});
|
|
} catch (o) {
|
|
r.notify({
|
|
state: "failed",
|
|
error: o instanceof Error || o instanceof DOMException ? o : new Error(String(o)),
|
|
handle: __privateMethod(this, _me_instances, c_fn).call(this, {
|
|
documentId: t
|
|
})
|
|
});
|
|
}
|
|
};
|
|
y_fn = async function(e) {
|
|
if (__privateGet(this, _t4)[e]) return __privateGet(this, _t4)[e];
|
|
const t = __privateMethod(this, _me_instances, c_fn).call(this, {
|
|
documentId: e
|
|
}), s = await (this.storageSubsystem ? this.storageSubsystem.loadDoc(t.documentId) : Promise.resolve(null));
|
|
return s ? (t.update(() => s), t.doneLoading()) : (await this.networkSubsystem.whenReady(), t.request()), __privateMethod(this, _me_instances, d_fn).call(this, t), t;
|
|
};
|
|
class U extends D {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "peerId");
|
|
__publicField(this, "peerMetadata");
|
|
}
|
|
}
|
|
class pe extends U {
|
|
constructor(e) {
|
|
super();
|
|
__privateAdd(this, _pe_instances);
|
|
__privateAdd(this, _e5);
|
|
__privateAdd(this, _s5, false);
|
|
__privateAdd(this, _o5, false);
|
|
__privateAdd(this, _t5, () => {
|
|
});
|
|
__privateAdd(this, _n5);
|
|
__privateAdd(this, _r3);
|
|
__privateAdd(this, _i2, []);
|
|
__privateSet(this, _r3, {
|
|
channelName: "broadcast",
|
|
peerWaitMs: 1e3,
|
|
...e ?? {}
|
|
}), __privateSet(this, _e5, new BroadcastChannel(__privateGet(this, _r3).channelName)), __privateSet(this, _n5, new Promise((t) => {
|
|
__privateSet(this, _t5, () => {
|
|
__privateSet(this, _o5, true), t();
|
|
}), setTimeout(() => __privateGet(this, _t5).call(this), __privateGet(this, _r3).peerWaitMs);
|
|
}));
|
|
}
|
|
isReady() {
|
|
return __privateGet(this, _o5);
|
|
}
|
|
whenReady() {
|
|
return __privateGet(this, _n5);
|
|
}
|
|
connect(e, t) {
|
|
this.peerId = e, this.peerMetadata = t, __privateSet(this, _s5, false), __privateGet(this, _e5).addEventListener("message", (s) => {
|
|
const r = s.data;
|
|
if ("targetId" in r && r.targetId !== this.peerId || __privateGet(this, _s5)) return;
|
|
const { senderId: n, type: o } = r;
|
|
switch (o) {
|
|
case "arrive":
|
|
{
|
|
const { peerMetadata: a } = r;
|
|
__privateGet(this, _e5).postMessage({
|
|
senderId: this.peerId,
|
|
targetId: n,
|
|
type: "welcome",
|
|
peerMetadata: this.peerMetadata
|
|
}), __privateMethod(this, _pe_instances, a_fn3).call(this, n, a);
|
|
}
|
|
break;
|
|
case "welcome":
|
|
{
|
|
const { peerMetadata: a } = r;
|
|
__privateMethod(this, _pe_instances, a_fn3).call(this, n, a);
|
|
}
|
|
break;
|
|
case "leave":
|
|
__privateSet(this, _i2, __privateGet(this, _i2).filter((a) => a !== n)), this.emit("peer-disconnected", {
|
|
peerId: n
|
|
});
|
|
break;
|
|
default:
|
|
if (!("data" in r)) this.emit("message", r);
|
|
else {
|
|
if (!r.data) throw new Error("We got a message without data, we can't send this.");
|
|
const a = r.data;
|
|
this.emit("message", {
|
|
...r,
|
|
data: new Uint8Array(a)
|
|
});
|
|
}
|
|
break;
|
|
}
|
|
}), __privateGet(this, _e5).postMessage({
|
|
senderId: this.peerId,
|
|
type: "arrive",
|
|
peerMetadata: t
|
|
});
|
|
}
|
|
send(e) {
|
|
if (__privateGet(this, _s5)) return false;
|
|
"data" in e ? __privateGet(this, _e5).postMessage({
|
|
...e,
|
|
data: e.data ? e.data.buffer.slice(e.data.byteOffset, e.data.byteOffset + e.data.byteLength) : void 0
|
|
}) : __privateGet(this, _e5).postMessage(e);
|
|
}
|
|
disconnect() {
|
|
__privateGet(this, _e5).postMessage({
|
|
senderId: this.peerId,
|
|
type: "leave"
|
|
});
|
|
for (const e of __privateGet(this, _i2)) this.emit("peer-disconnected", {
|
|
peerId: e
|
|
});
|
|
__privateSet(this, _s5, true);
|
|
}
|
|
}
|
|
_e5 = new WeakMap();
|
|
_s5 = new WeakMap();
|
|
_o5 = new WeakMap();
|
|
_t5 = new WeakMap();
|
|
_n5 = new WeakMap();
|
|
_r3 = new WeakMap();
|
|
_i2 = new WeakMap();
|
|
_pe_instances = new WeakSet();
|
|
a_fn3 = function(e, t) {
|
|
__privateGet(this, _t5).call(this), __privateGet(this, _i2).push(e), this.emit("peer-candidate", {
|
|
peerId: e,
|
|
peerMetadata: t
|
|
});
|
|
};
|
|
class ye {
|
|
constructor(e = "automerge", t = "documents") {
|
|
__publicField(this, "database");
|
|
__publicField(this, "store");
|
|
__publicField(this, "dbPromise");
|
|
this.database = e, this.store = t, this.dbPromise = this.createDatabasePromise();
|
|
}
|
|
createDatabasePromise() {
|
|
return new Promise((e, t) => {
|
|
const s = indexedDB.open(this.database, 1);
|
|
s.onerror = () => {
|
|
t(s.error);
|
|
}, s.onupgradeneeded = (r) => {
|
|
r.target.result.createObjectStore(this.store);
|
|
}, s.onsuccess = (r) => {
|
|
const n = r.target.result;
|
|
e(n);
|
|
};
|
|
});
|
|
}
|
|
async load(e) {
|
|
const s = (await this.dbPromise).transaction(this.store), n = s.objectStore(this.store).get(e);
|
|
return new Promise((o, a) => {
|
|
s.onerror = () => {
|
|
a(n.error);
|
|
}, n.onsuccess = (u) => {
|
|
const h = u.target.result;
|
|
h && typeof h == "object" && "binary" in h ? o(h.binary) : o(void 0);
|
|
};
|
|
});
|
|
}
|
|
async save(e, t) {
|
|
const r = (await this.dbPromise).transaction(this.store, "readwrite");
|
|
return r.objectStore(this.store).put({
|
|
key: e,
|
|
binary: t
|
|
}, e), new Promise((o, a) => {
|
|
r.onerror = () => {
|
|
a(r.error);
|
|
}, r.oncomplete = () => {
|
|
o();
|
|
};
|
|
});
|
|
}
|
|
async remove(e) {
|
|
const s = (await this.dbPromise).transaction(this.store, "readwrite");
|
|
return s.objectStore(this.store).delete(e), new Promise((n, o) => {
|
|
s.onerror = () => {
|
|
o(s.error);
|
|
}, s.oncomplete = () => {
|
|
n();
|
|
};
|
|
});
|
|
}
|
|
async loadRange(e) {
|
|
const t = await this.dbPromise, s = e, r = [
|
|
...e,
|
|
"\uFFFF"
|
|
], n = IDBKeyRange.bound(s, r), o = t.transaction(this.store), u = o.objectStore(this.store).openCursor(n), h = [];
|
|
return new Promise((p, c) => {
|
|
o.onerror = () => {
|
|
c(u.error);
|
|
}, u.onsuccess = (b) => {
|
|
const m = b.target.result;
|
|
m ? (h.push({
|
|
data: m.value.binary,
|
|
key: m.key
|
|
}), m.continue()) : p(h);
|
|
};
|
|
});
|
|
}
|
|
async removeRange(e) {
|
|
const t = await this.dbPromise, s = e, r = [
|
|
...e,
|
|
"\uFFFF"
|
|
], n = IDBKeyRange.bound(s, r), o = t.transaction(this.store, "readwrite");
|
|
return o.objectStore(this.store).delete(n), new Promise((u, h) => {
|
|
o.onerror = () => {
|
|
h(o.error);
|
|
}, o.oncomplete = () => {
|
|
u();
|
|
};
|
|
});
|
|
}
|
|
}
|
|
var w = null;
|
|
typeof WebSocket < "u" ? w = WebSocket : typeof MozWebSocket < "u" ? w = MozWebSocket : typeof global < "u" ? w = global.WebSocket || global.MozWebSocket : typeof window < "u" ? w = window.WebSocket || window.MozWebSocket : typeof self < "u" && (w = self.WebSocket || self.MozWebSocket);
|
|
const ge = (d) => d.type === "peer", be = (d) => d.type === "error", we = "1";
|
|
function g(d, e = "Assertion failed") {
|
|
if (d === false || d === null || d === void 0) {
|
|
const t = new Error(ve(e));
|
|
throw t.stack = Se(t.stack, "assert.ts"), t;
|
|
}
|
|
}
|
|
const ve = (d) => d.split(`
|
|
`).map((e) => e.trim()).join(`
|
|
`), Se = (d = "", e) => d.split(`
|
|
`).filter((t) => !t.includes(e)).join(`
|
|
`), Ie = (d) => {
|
|
const { buffer: e, byteOffset: t, byteLength: s } = d;
|
|
return e.slice(t, t + s);
|
|
};
|
|
class ke extends U {
|
|
constructor() {
|
|
super(...arguments);
|
|
__publicField(this, "socket");
|
|
}
|
|
}
|
|
class Pe extends ke {
|
|
constructor(e, t = 5e3) {
|
|
super();
|
|
__privateAdd(this, _Pe_instances);
|
|
__publicField(this, "url");
|
|
__publicField(this, "retryInterval");
|
|
__privateAdd(this, _e6, false);
|
|
__privateAdd(this, _s6);
|
|
__privateAdd(this, _o6, new Promise((e) => {
|
|
__privateSet(this, _s6, e);
|
|
}));
|
|
__privateAdd(this, _n6);
|
|
__privateAdd(this, _r4, P("automerge-repo:websocket:browser"));
|
|
__publicField(this, "remotePeerId");
|
|
__publicField(this, "onOpen", () => {
|
|
__privateGet(this, _r4).call(this, "open"), clearInterval(__privateGet(this, _n6)), __privateSet(this, _n6, void 0), this.join();
|
|
});
|
|
__publicField(this, "onClose", () => {
|
|
__privateGet(this, _r4).call(this, "close"), this.remotePeerId && this.emit("peer-disconnected", {
|
|
peerId: this.remotePeerId
|
|
}), this.retryInterval > 0 && !__privateGet(this, _n6) && setTimeout(() => (g(this.peerId), this.connect(this.peerId, this.peerMetadata)), this.retryInterval);
|
|
});
|
|
__publicField(this, "onMessage", (e) => {
|
|
this.receiveMessage(e.data);
|
|
});
|
|
__publicField(this, "onError", (e) => {
|
|
if ("error" in e && e.error.code !== "ECONNREFUSED") throw e.error;
|
|
__privateGet(this, _r4).call(this, "Connection failed, retrying...");
|
|
});
|
|
this.url = e, this.retryInterval = t, __privateSet(this, _r4, __privateGet(this, _r4).extend(e));
|
|
}
|
|
isReady() {
|
|
return __privateGet(this, _e6);
|
|
}
|
|
whenReady() {
|
|
return __privateGet(this, _o6);
|
|
}
|
|
connect(e, t) {
|
|
!this.socket || !this.peerId ? (__privateGet(this, _r4).call(this, "connecting"), this.peerId = e, this.peerMetadata = t ?? {}) : (__privateGet(this, _r4).call(this, "reconnecting"), g(e === this.peerId), this.socket.removeEventListener("open", this.onOpen), this.socket.removeEventListener("close", this.onClose), this.socket.removeEventListener("message", this.onMessage), this.socket.removeEventListener("error", this.onError)), __privateGet(this, _n6) || __privateSet(this, _n6, setInterval(() => {
|
|
this.connect(e, t);
|
|
}, this.retryInterval)), this.socket = new w(this.url), this.socket.binaryType = "arraybuffer", this.socket.addEventListener("open", this.onOpen), this.socket.addEventListener("close", this.onClose), this.socket.addEventListener("message", this.onMessage), this.socket.addEventListener("error", this.onError), setTimeout(() => __privateMethod(this, _Pe_instances, t_fn).call(this), 1e3), this.join();
|
|
}
|
|
join() {
|
|
g(this.peerId), g(this.socket), this.socket.readyState === w.OPEN && this.send(Ee(this.peerId, this.peerMetadata));
|
|
}
|
|
disconnect() {
|
|
g(this.peerId), g(this.socket);
|
|
const e = this.socket;
|
|
e && (e.removeEventListener("open", this.onOpen), e.removeEventListener("close", this.onClose), e.removeEventListener("message", this.onMessage), e.removeEventListener("error", this.onError), e.close()), clearInterval(__privateGet(this, _n6)), this.remotePeerId && this.emit("peer-disconnected", {
|
|
peerId: this.remotePeerId
|
|
}), this.socket = void 0;
|
|
}
|
|
send(e) {
|
|
var _a2;
|
|
if ("data" in e && ((_a2 = e.data) == null ? void 0 : _a2.byteLength) === 0) throw new Error("Tried to send a zero-length message");
|
|
if (g(this.peerId), !this.socket) {
|
|
__privateGet(this, _r4).call(this, "Tried to send on a disconnected socket.");
|
|
return;
|
|
}
|
|
if (this.socket.readyState !== w.OPEN) throw new Error(`Websocket not ready (${this.socket.readyState})`);
|
|
const t = oe(e);
|
|
this.socket.send(Ie(t));
|
|
}
|
|
peerCandidate(e, t) {
|
|
g(this.socket), __privateMethod(this, _Pe_instances, t_fn).call(this), this.remotePeerId = e, this.emit("peer-candidate", {
|
|
peerId: e,
|
|
peerMetadata: t
|
|
});
|
|
}
|
|
receiveMessage(e) {
|
|
let t;
|
|
try {
|
|
t = ie(new Uint8Array(e));
|
|
} catch (s) {
|
|
__privateGet(this, _r4).call(this, "error decoding message:", s);
|
|
return;
|
|
}
|
|
if (g(this.socket), e.byteLength === 0) throw new Error("received a zero-length message");
|
|
if (ge(t)) {
|
|
const { peerMetadata: s } = t;
|
|
__privateGet(this, _r4).call(this, `peer: ${t.senderId}`), this.peerCandidate(t.senderId, s);
|
|
} else be(t) ? __privateGet(this, _r4).call(this, `error: ${t.message}`) : this.emit("message", t);
|
|
}
|
|
}
|
|
_e6 = new WeakMap();
|
|
_s6 = new WeakMap();
|
|
_o6 = new WeakMap();
|
|
_Pe_instances = new WeakSet();
|
|
t_fn = function() {
|
|
var _a2;
|
|
__privateGet(this, _e6) || (__privateSet(this, _e6, true), (_a2 = __privateGet(this, _s6)) == null ? void 0 : _a2.call(this));
|
|
};
|
|
_n6 = new WeakMap();
|
|
_r4 = new WeakMap();
|
|
function Ee(d, e) {
|
|
return {
|
|
type: "join",
|
|
senderId: d,
|
|
peerMetadata: e,
|
|
supportedProtocolVersions: [
|
|
we
|
|
]
|
|
};
|
|
}
|
|
P("WebsocketServer");
|
|
let S = null;
|
|
Re = function() {
|
|
return S || (S = new me({
|
|
network: [
|
|
new Pe("wss://sync.automerge.org"),
|
|
new pe()
|
|
],
|
|
storage: new ye("p2p-poll-app")
|
|
}), S);
|
|
};
|
|
Me = function() {
|
|
S && (S.shutdown(), S = null);
|
|
};
|
|
});
|
|
export {
|
|
__tla,
|
|
Me as cleanupRepo,
|
|
Re as getRepo
|
|
};
|