@fireproof/core 0.5.11 → 0.5.12

package/dist/src/fireproof.js

@@ -9573,15 +9573,7 @@ var _polyfillNode_events = /*#__PURE__*/Object.freeze({
 
 var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_events);
 
-var streamBrowser;
-var hasRequiredStreamBrowser;
-
-function requireStreamBrowser () {
-	if (hasRequiredStreamBrowser) return streamBrowser;
-	hasRequiredStreamBrowser = 1;
-	streamBrowser = require$$0$1.EventEmitter;
-	return streamBrowser;
-}
+var streamBrowser = require$$0$1.EventEmitter;
 
 // shim for using process in browser
 // based off https://github.com/defunctzombie/node-process/blob/master/browser.js
@@ -9724,7 +9716,7 @@ var argv = [];
 var version$2 = ''; // empty string to avoid regexp issues
 var versions = {};
 var release = {};
-var config = {};
+var config$1 = {};
 
 function noop$2() {}
 
@@ -9801,7 +9793,7 @@ var browser$1$1 = {
   hrtime: hrtime,
   platform: platform,
   release: release,
-  config: config,
+  config: config$1,
   uptime: uptime
 };
 
@@ -9882,11 +9874,11 @@ function format(f) {
 // Mark that a method should not be used.
 // Returns a modified function which warns once by default.
 // If --no-deprecation is set, then it is a no-op.
-function deprecate$1(fn, msg) {
+function deprecate$2(fn, msg) {
   // Allow for deprecating things in the process of starting up.
   if (isUndefined(global$1.process)) {
     return function() {
-      return deprecate$1(fn, msg).apply(this, arguments);
+      return deprecate$2(fn, msg).apply(this, arguments);
     };
   }
 
@@ -10495,7 +10487,7 @@ var _polyfillNode_util = {
   isBoolean: isBoolean,
   isArray: isArray,
   inspect: inspect,
-  deprecate: deprecate$1,
+  deprecate: deprecate$2,
   format: format,
   debuglog: debuglog,
   promisify: promisify,
@@ -10508,7 +10500,7 @@ var _polyfillNode_util$1 = /*#__PURE__*/Object.freeze({
 	callbackify: callbackify,
 	debuglog: debuglog,
 	default: _polyfillNode_util,
-	deprecate: deprecate$1,
+	deprecate: deprecate$2,
 	format: format,
 	inherits: inherits$w,
 	inspect: inspect,
@@ -10696,108 +10688,99 @@ function requireBuffer_list () {
 	return buffer_list;
 }
 
-var destroy_1;
-var hasRequiredDestroy;
-
-function requireDestroy () {
-	if (hasRequiredDestroy) return destroy_1;
-	hasRequiredDestroy = 1;
-
-	// undocumented cb() API, needed for core, not for public API
-	function destroy(err, cb) {
-	  const readableDestroyed = this._readableState && this._readableState.destroyed;
-	  const writableDestroyed = this._writableState && this._writableState.destroyed;
-	  if (readableDestroyed || writableDestroyed) {
-	    if (cb) {
-	      cb(err);
-	    } else if (err) {
-	      if (!this._writableState) {
-	        process.nextTick(emitErrorNT, this, err);
-	      } else if (!this._writableState.errorEmitted) {
-	        this._writableState.errorEmitted = true;
-	        process.nextTick(emitErrorNT, this, err);
-	      }
-	    }
-	    return this;
-	  }
+// undocumented cb() API, needed for core, not for public API
+function destroy(err, cb) {
+  const readableDestroyed = this._readableState && this._readableState.destroyed;
+  const writableDestroyed = this._writableState && this._writableState.destroyed;
+  if (readableDestroyed || writableDestroyed) {
+    if (cb) {
+      cb(err);
+    } else if (err) {
+      if (!this._writableState) {
+        process.nextTick(emitErrorNT, this, err);
+      } else if (!this._writableState.errorEmitted) {
+        this._writableState.errorEmitted = true;
+        process.nextTick(emitErrorNT, this, err);
+      }
+    }
+    return this;
+  }
 
-	  // we set destroyed to true before firing error callbacks in order
-	  // to make it re-entrance safe in case destroy() is called within callbacks
+  // we set destroyed to true before firing error callbacks in order
+  // to make it re-entrance safe in case destroy() is called within callbacks
 
-	  if (this._readableState) {
-	    this._readableState.destroyed = true;
-	  }
+  if (this._readableState) {
+    this._readableState.destroyed = true;
+  }
 
-	  // if this is a duplex stream mark the writable part as destroyed as well
-	  if (this._writableState) {
-	    this._writableState.destroyed = true;
-	  }
-	  this._destroy(err || null, err => {
-	    if (!cb && err) {
-	      if (!this._writableState) {
-	        process.nextTick(emitErrorAndCloseNT, this, err);
-	      } else if (!this._writableState.errorEmitted) {
-	        this._writableState.errorEmitted = true;
-	        process.nextTick(emitErrorAndCloseNT, this, err);
-	      } else {
-	        process.nextTick(emitCloseNT, this);
-	      }
-	    } else if (cb) {
-	      process.nextTick(emitCloseNT, this);
-	      cb(err);
-	    } else {
-	      process.nextTick(emitCloseNT, this);
-	    }
-	  });
-	  return this;
-	}
-	function emitErrorAndCloseNT(self, err) {
-	  emitErrorNT(self, err);
-	  emitCloseNT(self);
-	}
-	function emitCloseNT(self) {
-	  if (self._writableState && !self._writableState.emitClose) return;
-	  if (self._readableState && !self._readableState.emitClose) return;
-	  self.emit('close');
-	}
-	function undestroy() {
-	  if (this._readableState) {
-	    this._readableState.destroyed = false;
-	    this._readableState.reading = false;
-	    this._readableState.ended = false;
-	    this._readableState.endEmitted = false;
-	  }
-	  if (this._writableState) {
-	    this._writableState.destroyed = false;
-	    this._writableState.ended = false;
-	    this._writableState.ending = false;
-	    this._writableState.finalCalled = false;
-	    this._writableState.prefinished = false;
-	    this._writableState.finished = false;
-	    this._writableState.errorEmitted = false;
-	  }
-	}
-	function emitErrorNT(self, err) {
-	  self.emit('error', err);
-	}
-	function errorOrDestroy(stream, err) {
-	  // We have tests that rely on errors being emitted
-	  // in the same tick, so changing this is semver major.
-	  // For now when you opt-in to autoDestroy we allow
-	  // the error to be emitted nextTick. In a future
-	  // semver major update we should change the default to this.
-
-	  const rState = stream._readableState;
-	  const wState = stream._writableState;
-	  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
-	}
-	destroy_1 = {
-	  destroy,
-	  undestroy,
-	  errorOrDestroy
-	};
-	return destroy_1;
+  // if this is a duplex stream mark the writable part as destroyed as well
+  if (this._writableState) {
+    this._writableState.destroyed = true;
+  }
+  this._destroy(err || null, err => {
+    if (!cb && err) {
+      if (!this._writableState) {
+        process.nextTick(emitErrorAndCloseNT, this, err);
+      } else if (!this._writableState.errorEmitted) {
+        this._writableState.errorEmitted = true;
+        process.nextTick(emitErrorAndCloseNT, this, err);
+      } else {
+        process.nextTick(emitCloseNT, this);
+      }
+    } else if (cb) {
+      process.nextTick(emitCloseNT, this);
+      cb(err);
+    } else {
+      process.nextTick(emitCloseNT, this);
+    }
+  });
+  return this;
+}
+function emitErrorAndCloseNT(self, err) {
+  emitErrorNT(self, err);
+  emitCloseNT(self);
+}
+function emitCloseNT(self) {
+  if (self._writableState && !self._writableState.emitClose) return;
+  if (self._readableState && !self._readableState.emitClose) return;
+  self.emit('close');
+}
+function undestroy() {
+  if (this._readableState) {
+    this._readableState.destroyed = false;
+    this._readableState.reading = false;
+    this._readableState.ended = false;
+    this._readableState.endEmitted = false;
+  }
+  if (this._writableState) {
+    this._writableState.destroyed = false;
+    this._writableState.ended = false;
+    this._writableState.ending = false;
+    this._writableState.finalCalled = false;
+    this._writableState.prefinished = false;
+    this._writableState.finished = false;
+    this._writableState.errorEmitted = false;
+  }
+}
+function emitErrorNT(self, err) {
+  self.emit('error', err);
+}
+function errorOrDestroy(stream, err) {
+  // We have tests that rely on errors being emitted
+  // in the same tick, so changing this is semver major.
+  // For now when you opt-in to autoDestroy we allow
+  // the error to be emitted nextTick. In a future
+  // semver major update we should change the default to this.
+
+  const rState = stream._readableState;
+  const wState = stream._writableState;
+  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
 }
+var destroy_1 = {
+  destroy,
+  undestroy,
+  errorOrDestroy
+};
 
 var errorsBrowser = {};
 
@@ -10927,109 +10910,92 @@ createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
 createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
 errorsBrowser.codes = codes;
 
-var state;
-var hasRequiredState;
-
-function requireState () {
-	if (hasRequiredState) return state;
-	hasRequiredState = 1;
-
-	const ERR_INVALID_OPT_VALUE = errorsBrowser.codes.ERR_INVALID_OPT_VALUE;
-	function highWaterMarkFrom(options, isDuplex, duplexKey) {
-	  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
-	}
-	function getHighWaterMark(state, options, duplexKey, isDuplex) {
-	  const hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
-	  if (hwm != null) {
-	    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
-	      const name = isDuplex ? duplexKey : 'highWaterMark';
-	      throw new ERR_INVALID_OPT_VALUE(name, hwm);
-	    }
-	    return Math.floor(hwm);
-	  }
-
-	  // Default value
-	  return state.objectMode ? 16 : 16 * 1024;
-	}
-	state = {
-	  getHighWaterMark
-	};
-	return state;
+const ERR_INVALID_OPT_VALUE = errorsBrowser.codes.ERR_INVALID_OPT_VALUE;
+function highWaterMarkFrom(options, isDuplex, duplexKey) {
+  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
 }
+function getHighWaterMark(state, options, duplexKey, isDuplex) {
+  const hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
+  if (hwm != null) {
+    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+      const name = isDuplex ? duplexKey : 'highWaterMark';
+      throw new ERR_INVALID_OPT_VALUE(name, hwm);
+    }
+    return Math.floor(hwm);
+  }
 
-var browser$b;
-var hasRequiredBrowser$3;
+  // Default value
+  return state.objectMode ? 16 : 16 * 1024;
+}
+var state = {
+  getHighWaterMark
+};
 
-function requireBrowser$3 () {
-	if (hasRequiredBrowser$3) return browser$b;
-	hasRequiredBrowser$3 = 1;
-	/**
-	 * Module exports.
-	 */
+/**
+ * Module exports.
+ */
 
-	browser$b = deprecate;
+var browser$b = deprecate$1;
 
-	/**
-	 * Mark that a method should not be used.
-	 * Returns a modified function which warns once by default.
-	 *
-	 * If `localStorage.noDeprecation = true` is set, then it is a no-op.
-	 *
-	 * If `localStorage.throwDeprecation = true` is set, then deprecated functions
-	 * will throw an Error when invoked.
-	 *
-	 * If `localStorage.traceDeprecation = true` is set, then deprecated functions
-	 * will invoke `console.trace()` instead of `console.error()`.
-	 *
-	 * @param {Function} fn - the function to deprecate
-	 * @param {String} msg - the string to print to the console when `fn` is invoked
-	 * @returns {Function} a new "deprecated" version of `fn`
-	 * @api public
-	 */
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */
 
-	function deprecate (fn, msg) {
-	  if (config('noDeprecation')) {
-	    return fn;
-	  }
+function deprecate$1 (fn, msg) {
+  if (config('noDeprecation')) {
+    return fn;
+  }
 
-	  var warned = false;
-	  function deprecated() {
-	    if (!warned) {
-	      if (config('throwDeprecation')) {
-	        throw new Error(msg);
-	      } else if (config('traceDeprecation')) {
-	        console.trace(msg);
-	      } else {
-	        console.warn(msg);
-	      }
-	      warned = true;
-	    }
-	    return fn.apply(this, arguments);
-	  }
+  var warned = false;
+  function deprecated() {
+    if (!warned) {
+      if (config('throwDeprecation')) {
+        throw new Error(msg);
+      } else if (config('traceDeprecation')) {
+        console.trace(msg);
+      } else {
+        console.warn(msg);
+      }
+      warned = true;
+    }
+    return fn.apply(this, arguments);
+  }
 
-	  return deprecated;
-	}
+  return deprecated;
+}
 
-	/**
-	 * Checks `localStorage` for boolean values for the given `name`.
-	 *
-	 * @param {String} name
-	 * @returns {Boolean}
-	 * @api private
-	 */
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */
 
-	function config (name) {
-	  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
-	  try {
-	    if (!commonjsGlobal.localStorage) return false;
-	  } catch (_) {
-	    return false;
-	  }
-	  var val = commonjsGlobal.localStorage[name];
-	  if (null == val) return false;
-	  return String(val).toLowerCase() === 'true';
-	}
-	return browser$b;
+function config (name) {
+  // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+  try {
+    if (!commonjsGlobal.localStorage) return false;
+  } catch (_) {
+    return false;
+  }
+  var val = commonjsGlobal.localStorage[name];
+  if (null == val) return false;
+  return String(val).toLowerCase() === 'true';
 }
 
 var _stream_writable;
@@ -11060,12 +11026,12 @@ function require_stream_writable () {
 
 	/*<replacement>*/
 	const internalUtil = {
-	  deprecate: requireBrowser$3()
+	  deprecate: browser$b
 	};
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStreamBrowser();
+	var Stream = streamBrowser;
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -11076,8 +11042,8 @@ function require_stream_writable () {
 	function _isUint8Array(obj) {
 	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 	}
-	const destroyImpl = requireDestroy();
-	const _require = requireState(),
+	const destroyImpl = destroy_1;
+	const _require = state,
 	  getHighWaterMark = _require.getHighWaterMark;
 	const _require$codes = errorsBrowser.codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
@@ -12271,7 +12237,7 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	/*<replacement>*/
-	var Stream = requireStreamBrowser();
+	var Stream = streamBrowser;
 	/*</replacement>*/
 
 	const Buffer = require$$6$1.Buffer;
@@ -12294,8 +12260,8 @@ function require_stream_readable () {
 	/*</replacement>*/
 
 	const BufferList = requireBuffer_list();
-	const destroyImpl = requireDestroy();
-	const _require = requireState(),
+	const destroyImpl = destroy_1;
+	const _require = state,
 	  getHighWaterMark = _require.getHighWaterMark;
 	const _require$codes = errorsBrowser.codes,
 	  ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
@@ -15661,7 +15627,7 @@ function WriteReq(chunk, encoding, cb) {
 
 function WritableState(options, stream) {
   Object.defineProperty(this, 'buffer', {
-    get: deprecate$1(function () {
+    get: deprecate$2(function () {
       return this.getBuffer();
     }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.')
   });
@@ -37410,8 +37376,8 @@ class TransactionBlockstore {
     if (doSync) {
       // const all =
       await Promise.all([...this.syncs].map(async sync => sync.sendUpdate(innerBlockstore).catch(e => {
-        console.error('sync error', e);
-        this.syncs.delete(sync);
+        console.error('sync error, cancelling', e);
+        sync.destroy();
       })));
     }
   }
@@ -41048,6 +41014,7 @@ class Sync {
    * @memberof Sync
    * @static
    */
+  status = 'new'
   constructor (database, PeerClass = simplePeer) {
     this.database = database;
     this.database.blocks.syncs.add(this); // should this happen during setup?
@@ -41063,6 +41030,7 @@ class Sync {
   }
 
   async offer () {
+    this.status = 'offering';
     return this.setupPeer(true)
   }
 
@@ -41070,11 +41038,13 @@ class Sync {
     const offer = JSON.parse(atob(base64offer));
     const p = this.setupPeer(false);
     this.peer.signal(offer);
+    this.status = 'accepting';
     return p
   }
 
   connect (base64accept) {
     const accept = JSON.parse(atob(base64accept));
+    this.status = 'connecting';
     this.peer.signal(accept);
   }
 
@@ -41105,6 +41075,7 @@ class Sync {
       // console.log('not a car', data.toString())
     }
     if (reader) {
+      this.status = 'parking car';
       const blz = new Set();
       for await (const block of reader.blocks()) {
         blz.add(block);
@@ -41121,23 +41092,28 @@ class Sync {
       // )
       // @ts-ignore
       reader.entries = reader.blocks;
-      await this.database.blocks.commit({
-        label: 'sync',
-        entries: () => [...blz],
-        get: async cid => await reader.get(cid),
-        lastCid: [...blz][0].cid // doesn't matter
-      }, false);
+      await this.database.blocks.commit(
+        {
+          label: 'sync',
+          entries: () => [...blz],
+          get: async cid => await reader.get(cid),
+          lastCid: [...blz][0].cid // doesn't matter
+        },
+        false
+      );
       // first arg could be the roots parents?
       // get the roots parents
-      const parents = await Promise.all(roots.map(async (cid) => {
-        const rbl = await reader.get(cid);
-        if (!rbl) {
-          console.log('missing root block', cid.toString(), reader);
-          throw new Error('missing root block')
-        }
-        const block = await decodeEventBlock(rbl.bytes);
-        return block.value.parents
-      }));
+      const parents = await Promise.all(
+        roots.map(async cid => {
+          const rbl = await reader.get(cid);
+          if (!rbl) {
+            console.log('missing root block', cid.toString(), reader);
+            throw new Error('missing root block')
+          }
+          const block = await decodeEventBlock(rbl.bytes);
+          return block.value.parents
+        })
+      );
       this.database.applyClock(parents.flat(), roots);
       this.database.notifyReset();
       // console.log('after', this.database.clockToJSON())
@@ -41147,6 +41123,7 @@ class Sync {
       const message = JSON.parse(data.toString());
       // console.log('got message', message)
       if (message.ok) {
+        this.status = 'ok';
         this.pushBacklogResolve({ ok: true });
       } else if (message.clock) {
         const reqCidDiff = message;
@@ -41154,12 +41131,14 @@ class Sync {
         console.log('got diff', reqCidDiff);
         const carBlock = await Sync.makeCar(this.database, null, reqCidDiff.cids);
         if (!carBlock) {
-        // we are full synced
-        // console.log('we are full synced')
+          // we are full synced
+          // console.log('we are full synced')
+          this.status = 'full synced';
           this.peer.send(JSON.stringify({ ok: true }));
           // this.pushBacklogResolve({ ok: true })
         } else {
-        // console.log('do send', carBlock.bytes.length)
+          // console.log('do send', carBlock.bytes.length)
+          this.status = 'sending diff car';
           this.peer.send(carBlock.bytes);
           // this.pushBacklogResolve({ ok: true })
         }
@@ -41167,10 +41146,18 @@ class Sync {
     }
   }
 
+  destroy () {
+    this.database.blocks.syncs.delete(this);
+    this.status = 'destroyed';
+    this.peer.destroy();
+  }
+
   async sendUpdate (blockstore) {
+    if (!this.peer) return
     // console.log('send update from', this.database.instanceId)
     // todo should send updates since last sync
     const newCar = await blocksToCarBlock(blockstore.lastCid, blockstore);
+    this.status = 'sending update car';
     this.peer.send(newCar.bytes);
   }
 
@@ -41183,6 +41170,7 @@ class Sync {
       cids: allCIDs.map(cid => cid.toString())
     };
     // console.log('send diff', reqCidDiff)
+    this.status = 'sending cid diff';
     this.peer.send(JSON.stringify(reqCidDiff));
   }