@fireproof/vendor 2.0.2 → 3.0.0

package/src/@web3-storage/pail/src/clock/index.js

@@ -1,182 +0,0 @@
-import { Block, encode, decode } from 'multiformats/block'
-import { sha256 } from 'multiformats/hashes/sha2'
-import * as cbor from '@ipld/dag-cbor'
-// eslint-disable-next-line no-unused-vars
-import * as API from './api.js'
-
-/**
- * Advance the clock by adding an event.
- *
- * @template T
- * @param {API.BlockFetcher} blocks Block storage.
- * @param {API.EventLink<T>[]} head The head of the clock.
- * @param {API.EventLink<T>} event The event to add.
- */
-export const advance = async (blocks, head, event) => {
-  const events = new EventFetcher(blocks)
-  const headmap = new Map(head.map(cid => [cid.toString(), cid]))
-  if (headmap.has(event.toString())) return head
-
-  // does event contain the clock?
-  let changed = false
-  for (const cid of head) {
-    if (await contains(events, event, cid)) {
-      headmap.delete(cid.toString())
-      headmap.set(event.toString(), event)
-      changed = true
-    }
-  }
-  if (changed) {
-    return [...headmap.values()]
-  }
-
-  // does clock contain the event?
-  for (const p of head) {
-    if (await contains(events, p, event)) {
-      return head
-    }
-  }
-
-  return head.concat(event)
-}
-
-/**
- * @template T
- * @extends {Block<API.EventView<T>, typeof cbor.code, typeof sha256.code, 1>}
- * @implements {API.EventBlockView<T>}
- */
-export class EventBlock extends Block {
-  /**
-   * @param {object} config
-   * @param {API.EventLink<T>} config.cid
-   * @param {Event} config.value
-   * @param {Uint8Array} config.bytes
-   * @param {string} config.prefix
-   */
-  constructor ({ cid, value, bytes, prefix }) {
-    // @ts-expect-error
-    super({ cid, value, bytes })
-    this.prefix = prefix
-  }
-
-  /**
-   * @template T
-   * @param {T} data
-   * @param {API.EventLink<T>[]} [parents]
-   */
-  static create (data, parents) {
-    return encodeEventBlock({ data, parents: parents ?? [] })
-  }
-}
-
-/** @template T */
-export class EventFetcher {
-  /** @param {API.BlockFetcher} blocks */
-  constructor (blocks) {
-    /** @private */
-    this._blocks = blocks
-  }
-
-  /**
-   * @param {API.EventLink<T>} link
-   * @returns {Promise<API.EventBlockView<T>>}
-   */
-  async get (link) {
-    const block = await this._blocks.get(link)
-    if (!block) throw new Error(`missing block: ${link}`)
-    return decodeEventBlock(block.bytes)
-  }
-}
-
-/**
- * @template T
- * @param {API.EventView<T>} value
- * @returns {Promise<API.EventBlockView<T>>}
- */
-export const encodeEventBlock = async (value) => {
-  // TODO: sort parents
-  const { cid, bytes } = await encode({ value, codec: cbor, hasher: sha256 })
-  // @ts-expect-error
-  return new Block({ cid, value, bytes })
-}
-
-/**
- * @template T
- * @param {Uint8Array} bytes
- * @returns {Promise<API.EventBlockView<T>>}
- */
-export const decodeEventBlock = async (bytes) => {
-  const { cid, value } = await decode({ bytes, codec: cbor, hasher: sha256 })
-  // @ts-expect-error
-  return new Block({ cid, value, bytes })
-}
-
-/**
- * Returns true if event "a" contains event "b". Breadth first search.
- * @template T
- * @param {EventFetcher<T>} events
- * @param {API.EventLink<T>} a
- * @param {API.EventLink<T>} b
- */
-const contains = async (events, a, b) => {
-  if (a.toString() === b.toString()) return true
-  const [{ value: aevent }, { value: bevent }] = await Promise.all([events.get(a), events.get(b)])
-  const links = [...aevent.parents]
-  const seen = new Set()
-  while (links.length) {
-    const link = links.shift()
-    if (!link) break
-    if (link.toString() === b.toString()) return true
-    // if any of b's parents are this link, then b cannot exist in any of the
-    // tree below, since that would create a cycle.
-    if (bevent.parents.some(p => link.toString() === p.toString())) continue
-    if (seen.has(link.toString())) continue
-    seen.add(link.toString())
-    const { value: event } = await events.get(link)
-    links.push(...event.parents)
-  }
-  return false
-}
-
-/**
- * @template T
- * @param {API.BlockFetcher} blocks Block storage.
- * @param {API.EventLink<T>[]} head
- * @param {object} [options]
- * @param {(b: API.EventBlockView<T>) => string} [options.renderNodeLabel]
- */
-export const vis = async function * (blocks, head, options = {}) {
-  const renderNodeLabel = options.renderNodeLabel ?? (b => shortLink(b.cid))
-  const events = new EventFetcher(blocks)
-  yield 'digraph clock {'
-  yield '  node [shape=point fontname="Courier"]; head;'
-  const hevents = await Promise.all(head.map(link => events.get(link)))
-  /** @type {import('multiformats').Link<API.EventView<any>>[]} */
-  const links = []
-  const nodes = new Set()
-  for (const e of hevents) {
-    nodes.add(e.cid.toString())
-    yield `  node [shape=oval fontname="Courier"]; ${e.cid} [label="${renderNodeLabel(e)}"];`
-    yield `  head -> ${e.cid};`
-    for (const p of e.value.parents) {
-      yield `  ${e.cid} -> ${p};`
-    }
-    links.push(...e.value.parents)
-  }
-  while (links.length) {
-    const link = links.shift()
-    if (!link) break
-    if (nodes.has(link.toString())) continue
-    nodes.add(link.toString())
-    const block = await events.get(link)
-    yield `  node [shape=oval]; ${link} [label="${renderNodeLabel(block)}" fontname="Courier"];`
-    for (const p of block.value.parents) {
-      yield `  ${link} -> ${p};`
-    }
-    links.push(...block.value.parents)
-  }
-  yield '}'
-}
-
-/** @param {import('multiformats').UnknownLink} l */
-const shortLink = l => `${String(l).slice(0, 4)}..${String(l).slice(-4)}`

package/src/@web3-storage/pail/src/crdt/api.js

@@ -1 +0,0 @@
-export {}

package/src/@web3-storage/pail/src/crdt/api.ts

@@ -1,33 +0,0 @@
-import { ShardDiff, ShardLink, UnknownLink } from '../api.js'
-import { EventLink, EventBlockView } from '../clock/api.js'
-
-export { BlockFetcher, UnknownLink, ShardBlockView, ShardDiff, ShardLink, EntriesOptions } from '../api.js'
-export { EventBlockView, EventLink } from '../clock/api.js'
-
-export interface Result extends ShardDiff {
-  root: ShardLink
-  head: EventLink<Operation>[]
-  event?: EventBlockView<Operation>
-}
-
-export type Operation = (
-  | PutOperation
-  | DeleteOperation
-  | BatchOperation
-) & { root: ShardLink }
-
-export interface PutOperation {
-  type: 'put',
-  key: string
-  value: UnknownLink
-}
-
-export interface DeleteOperation {
-  type: 'del',
-  key: string
-}
-
-export interface BatchOperation {
-  type: 'batch',
-  ops: Array<PutOperation|DeleteOperation>
-}

package/src/@web3-storage/pail/src/crdt/batch/api.js

@@ -1 +0,0 @@
-export {}

package/src/@web3-storage/pail/src/crdt/batch/api.ts

@@ -1,30 +0,0 @@
-import {
-  Batcher,
-  BatcherShardEntry,
-  ShardBlockView,
-  BlockFetcher,
-  ShardLink,
-  UnknownLink
-} from '../../batch/api.js'
-import { Operation, BatchOperation, EventLink, Result } from '../api.js'
-
-export {
-  Batcher,
-  BatcherShardEntry,
-  ShardBlockView,
-  BlockFetcher,
-  ShardLink,
-  UnknownLink,
-  Operation,
-  BatchOperation,
-  EventLink,
-  Result
-}
-
-export interface CRDTBatcher extends Batcher {
-  /**
-   * Encode all altered shards in the batch and return the new root CID, new
-   * clock head, the new clock event and the difference blocks.
-   */
-  commit (): Promise<Result>
-}

package/src/@web3-storage/pail/src/crdt/batch/index.js

@@ -1,155 +0,0 @@
-// eslint-disable-next-line no-unused-vars
-import * as API from './api.js'
-import * as Shard from '../../shard.js'
-import { ShardFetcher, ShardBlock } from '../../shard.js'
-import * as Batch from '../../batch/index.js'
-import { BatchCommittedError } from '../../batch/index.js'
-import * as CRDT from '../index.js'
-import * as Clock from '../../clock/index.js'
-import { EventBlock } from '../../clock/index.js'
-import { MemoryBlockstore, MultiBlockFetcher } from '../../block.js'
-
-export { BatchCommittedError }
-
-/** @implements {API.CRDTBatcher} */
-class Batcher {
-  #committed = false
-
-  /**
-   * @param {object} init
-   * @param {API.BlockFetcher} init.blocks Block storage.
-   * @param {API.EventLink<API.Operation>[]} init.head Merkle clock head.
-   * @param {API.BatcherShardEntry[]} init.entries The entries in this shard.
-   * @param {string} init.prefix Key prefix.
-   * @param {number} init.version Shard compatibility version.
-   * @param {string} init.keyChars Characters allowed in keys, referring to a known character set.
-   * @param {number} init.maxKeySize Max key size in bytes.
-   * @param {API.ShardBlockView} init.base Original shard this batcher is based on.
-   * @param {API.ShardBlockView[]} init.additions Additions to include in the committed batch.
-   * @param {API.ShardBlockView[]} init.removals Removals to include in the committed batch.
-   */
-  constructor ({ blocks, head, entries, prefix, version, keyChars, maxKeySize, base, additions, removals }) {
-    this.blocks = blocks
-    this.head = head
-    this.prefix = prefix
-    this.entries = [...entries]
-    this.base = base
-    this.version = version
-    this.keyChars = keyChars
-    this.maxKeySize = maxKeySize
-    this.additions = additions
-    this.removals = removals
-    /** @type {API.BatchOperation['ops']} */
-    this.ops = []
-  }
-
-  /**
-   * @param {string} key The key of the value to put.
-   * @param {API.UnknownLink} value The value to put.
-   * @returns {Promise<void>}
-   */
-  async put (key, value) {
-    if (this.#committed) throw new BatchCommittedError()
-    await Batch.put(this.blocks, this, key, value)
-    this.ops.push({ type: 'put', key, value })
-  }
-
-  async commit () {
-    if (this.#committed) throw new BatchCommittedError()
-    this.#committed = true
-
-    const res = await Batch.commit(this)
-
-    /** @type {API.Operation} */
-    const data = { type: 'batch', ops: this.ops, root: res.root }
-    const event = await EventBlock.create(data, this.head)
-
-    const mblocks = new MemoryBlockstore()
-    const blocks = new MultiBlockFetcher(mblocks, this.blocks)
-    mblocks.putSync(event.cid, event.bytes)
-
-    const head = await Clock.advance(blocks, this.head, event.cid)
-
-    /** @type {Map<string, API.ShardBlockView>} */
-    const additions = new Map()
-    /** @type {Map<string, API.ShardBlockView>} */
-    const removals = new Map()
-
-    for (const a of this.additions) {
-      additions.set(a.cid.toString(), a)
-    }
-    for (const r of this.removals) {
-      removals.set(r.cid.toString(), r)
-    }
-
-    for (const a of res.additions) {
-      if (removals.has(a.cid.toString())) {
-        removals.delete(a.cid.toString())
-      }
-      additions.set(a.cid.toString(), a)
-    }
-    for (const r of res.removals) {
-      if (additions.has(r.cid.toString())) {
-        additions.delete(r.cid.toString())
-      } else {
-        removals.set(r.cid.toString(), r)
-      }
-    }
-
-    return {
-      head,
-      event,
-      root: res.root,
-      additions: [...additions.values()],
-      removals: [...removals.values()]
-    }
-  }
-
-  /**
-   * @param {object} init
-   * @param {API.BlockFetcher} init.blocks Block storage.
-   * @param {API.EventLink<API.Operation>[]} init.head Merkle clock head.
-   */
-  static async create ({ blocks, head }) {
-    const mblocks = new MemoryBlockstore()
-    blocks = new MultiBlockFetcher(mblocks, blocks)
-
-    if (!head.length) {
-      const base = await ShardBlock.create()
-      mblocks.putSync(base.cid, base.bytes)
-      return new Batcher({
-        blocks,
-        head,
-        entries: [],
-        base,
-        additions: [base],
-        removals: [],
-        ...Shard.configure(base.value)
-      })
-    }
-
-    const { root, additions, removals } = await CRDT.root(blocks, head)
-    for (const a of additions) {
-      mblocks.putSync(a.cid, a.bytes)
-    }
-
-    const shards = new ShardFetcher(blocks)
-    const base = await shards.get(root)
-    return new Batcher({
-      blocks,
-      head,
-      entries: base.value.entries,
-      base,
-      additions,
-      removals,
-      ...Shard.configure(base.value)
-    })
-  }
-}
-
-/**
- * @param {API.BlockFetcher} blocks Bucket block storage.
- * @param {API.EventLink<API.Operation>[]} head Merkle clock head.
- * @returns {Promise<API.CRDTBatcher>}
- */
-export const create = (blocks, head) => Batcher.create({ blocks, head })