@fireproof/vendor 0.0.0-smoke → 0.0.2-dev-test

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

@@ -1,90 +0,0 @@
-import { Link, UnknownLink, BlockView, Block, Version } from 'multiformats'
-import { sha256 } from 'multiformats/hashes/sha2'
-import * as dagCBOR from "@fireproof/vendor/@ipld/dag-cbor"
-
-export { Link, UnknownLink, BlockView, Block, Version }
-
-export type ShardEntryValueValue = UnknownLink
-
-export type ShardEntryLinkValue = [ShardLink]
-
-export type ShardEntryLinkAndValueValue = [ShardLink, UnknownLink]
-
-export type ShardValueEntry = [key: string, value: ShardEntryValueValue]
-
-export type ShardLinkEntry = [key: string, value: ShardEntryLinkValue | ShardEntryLinkAndValueValue]
-
-/** Single key/value entry within a shard. */
-export type ShardEntry = [key: string, value: ShardEntryValueValue | ShardEntryLinkValue | ShardEntryLinkAndValueValue]
-
-export interface Shard extends ShardConfig {
-  entries: ShardEntry[]
-}
-
-export type ShardLink = Link<Shard, typeof dagCBOR.code, typeof sha256.code, 1>
-
-export interface ShardBlockView extends BlockView<Shard, typeof dagCBOR.code, typeof sha256.code, 1> {}
-
-export interface ShardDiff {
-  additions: ShardBlockView[]
-  removals: ShardBlockView[]
-}
-
-export interface BlockFetcher {
-  get<T = unknown, C extends number = number, A extends number = number, V extends Version = 1> (link: Link<T, C, A, V>):
-    Promise<Block<T, C, A, V> | undefined>
-}
-
-export interface ShardConfig {
-  /** Shard compatibility version. */
-  version: number
-  /**
-   * Characters allowed in keys, referring to a known character set.
-   * e.g. "ascii" refers to the printable ASCII characters in the code range 32-126.
-   */
-  keyChars: string
-  /** Max key size in bytes - default 4096 bytes. */
-  maxKeySize: number
-  /** The key prefix from the root to this shard. */
-  prefix: string
-}
-
-export type ShardOptions = Partial<ShardConfig>
-
-export interface KeyPrefixOption {
-  /** Filter results to entries with keys prefixed with this string. */
-  prefix: string
-}
-
-export type KeyRangeOption =
-  | KeyLowerBoundRangeOption
-  | KeyUpperBoundRangeOption
-  | (KeyLowerBoundRangeOption & KeyUpperBoundRangeOption)
-
-export type KeyLowerBoundRangeOption =
-  | KeyLowerBoundRangeExclusiveOption
-  | KeyLowerBoundRangeInclusiveOption
-
-export interface KeyLowerBoundRangeExclusiveOption {
-  gt: string
-}
-
-export interface KeyLowerBoundRangeInclusiveOption {
-  gte: string
-}
-
-export type KeyUpperBoundRangeOption =
-  | KeyUpperBoundRangeExclusiveOption
-  | KeyUpperBoundRangeInclusiveOption
-
-export interface KeyUpperBoundRangeExclusiveOption {
-  lt: string
-}
-
-export interface KeyUpperBoundRangeInclusiveOption {
-  lte: string
-}
-
-export type EntriesOptions =
-  | KeyPrefixOption
-  | KeyRangeOption

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

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

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

@@ -1,59 +0,0 @@
-import {
-  UnknownLink,
-  ShardLink,
-  ShardDiff,
-  ShardEntry,
-  ShardEntryValueValue,
-  ShardEntryLinkValue,
-  ShardEntryLinkAndValueValue,
-  ShardConfig,
-  ShardOptions,
-  ShardBlockView,
-  BlockFetcher
-} from '../api.js'
-
-export {
-  UnknownLink,
-  ShardLink,
-  ShardDiff,
-  ShardEntry,
-  ShardEntryValueValue,
-  ShardEntryLinkValue,
-  ShardEntryLinkAndValueValue,
-  ShardConfig,
-  ShardOptions,
-  ShardBlockView,
-  BlockFetcher
-}
-
-export interface BatcherShard extends ShardConfig {
-  base?: ShardBlockView
-  entries: BatcherShardEntry[]
-}
-
-export interface BatcherShardInit extends ShardOptions {
-  base?: ShardBlockView
-  entries?: BatcherShardEntry[]
-}
-
-export type BatcherShardEntry = [
-  key: string,
-  value: ShardEntryValueValue | ShardEntryLinkValue | ShardEntryLinkAndValueValue | ShardEntryShardValue | ShardEntryShardAndValueValue
-]
-
-export type ShardEntryShardValue = [BatcherShard]
-
-export type ShardEntryShardAndValueValue = [BatcherShard, UnknownLink]
-
-export interface Batcher {
-  /**
-   * Put a value (a CID) for the given key. If the key exists it's value is
-   * overwritten.
-   */
-  put (key: string, value: UnknownLink): Promise<void>
-  /**
-   * Encode all altered shards in the batch and return the new root CID and
-   * difference blocks.
-   */
-  commit (): Promise<{ root: ShardLink } & ShardDiff>
-}

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

@@ -1,258 +0,0 @@
-// eslint-disable-next-line no-unused-vars
-import * as API from './api.js'
-import { ShardFetcher, isPrintableASCII } from '../shard.js'
-import * as Shard from '../shard.js'
-import * as BatcherShard from './shard.js'
-
-/** @implements {API.Batcher} */
-class Batcher {
-  #committed = false
-
-  /**
-   * @param {object} init
-   * @param {API.BlockFetcher} init.blocks Block storage.
-   * @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.
-   */
-  constructor ({ blocks, entries, prefix, version, keyChars, maxKeySize, base }) {
-    this.blocks = blocks
-    this.prefix = prefix
-    this.entries = [...entries]
-    this.base = base
-    this.version = version
-    this.keyChars = keyChars
-    this.maxKeySize = maxKeySize
-  }
-
-  /**
-   * @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()
-    return put(this.blocks, this, key, value)
-  }
-
-  async commit () {
-    if (this.#committed) throw new BatchCommittedError()
-    this.#committed = true
-    return commit(this)
-  }
-
-  /**
-   * @param {object} init
-   * @param {API.BlockFetcher} init.blocks Block storage.
-   * @param {API.ShardLink} init.link CID of the shard block.
-   */
-  static async create ({ blocks, link }) {
-    const shards = new ShardFetcher(blocks)
-    const base = await shards.get(link)
-    return new Batcher({ blocks, base, ...base.value })
-  }
-}
-
-/**
- * @param {API.BlockFetcher} blocks
- * @param {API.BatcherShard} shard
- * @param {string} key The key of the value to put.
- * @param {API.UnknownLink} value The value to put.
- * @returns {Promise<void>}
- */
-export const put = async (blocks, shard, key, value) => {
-  if (shard.keyChars !== Shard.KeyCharsASCII) {
-    throw new Error(`unsupported key character set: ${shard.keyChars}`)
-  }
-  if (!isPrintableASCII(key)) {
-    throw new Error('key contains non-ASCII characters')
-  }
-  // ensure utf8 encoded key is smaller than max
-  if (new TextEncoder().encode(key).length > shard.maxKeySize) {
-    throw new Error(`UTF-8 encoded key exceeds max size of ${shard.maxKeySize} bytes`)
-  }
-
-  const shards = new ShardFetcher(blocks)
-  const dest = await traverse(shards, shard, key)
-  if (dest.shard !== shard) {
-    shard = dest.shard
-    key = dest.key
-  }
-
-  /** @type {API.BatcherShardEntry} */
-  let entry = [dest.key, value]
-  let targetEntries = [...dest.shard.entries]
-
-  for (const [i, e] of targetEntries.entries()) {
-    const [k, v] = e
-
-    // is this just a replace?
-    if (k === dest.key) break
-
-    // do we need to shard this entry?
-    const shortest = k.length < dest.key.length ? k : dest.key
-    const other = shortest === k ? dest.key : k
-    let common = ''
-    for (const char of shortest) {
-      const next = common + char
-      if (!other.startsWith(next)) break
-      common = next
-    }
-    if (common.length) {
-      /** @type {API.ShardEntry[]} */
-      let entries = []
-
-      // if the existing entry key or new key is equal to the common prefix,
-      // then the existing value / new value needs to persist in the parent
-      // shard. Otherwise they persist in this new shard.
-      if (common !== dest.key) {
-        entries = Shard.putEntry(entries, [dest.key.slice(common.length), value])
-      }
-      if (common !== k) {
-        entries = Shard.putEntry(entries, asShardEntry([k.slice(common.length), v]))
-      }
-
-      let child = BatcherShard.create({
-        ...Shard.configure(dest.shard),
-        prefix: dest.shard.prefix + common,
-        entries
-      })
-  
-      // need to spread as access by index does not consider utf-16 surrogates
-      const commonChars = [...common]
-
-      // create parent shards for each character of the common prefix
-      for (let i = commonChars.length - 1; i > 0; i--) {
-        /** @type {API.ShardEntryShardValue | API.ShardEntryShardAndValueValue} */
-        let parentValue
-        // if the first iteration and the existing entry key is equal to the
-        // common prefix, then existing value needs to persist in this parent
-        if (i === commonChars.length - 1 && common === k) {
-          if (Array.isArray(v)) throw new Error('found a shard link when expecting a value')
-          parentValue = [child, v]
-        } else if (i === commonChars.length - 1 && common === dest.key) {
-          parentValue = [child, value]
-        } else {
-          parentValue = [child]
-        }
-        const parent = BatcherShard.create({
-          ...Shard.configure(dest.shard),
-          prefix: dest.shard.prefix + commonChars.slice(0, i).join(''),
-          entries: [[commonChars[i], parentValue]]
-        })
-        child = parent
-      }
-
-      // remove the sharded entry
-      targetEntries.splice(i, 1)
-
-      // create the entry that will be added to target
-      if (commonChars.length === 1 && common === k) {
-        if (Array.isArray(v)) throw new Error('found a shard link when expecting a value')
-        entry = [commonChars[0], [child, v]]
-      } else if (commonChars.length === 1 && common === dest.key) {
-        entry = [commonChars[0], [child, value]]
-      } else {
-        entry = [commonChars[0], [child]]
-      }
-      break
-    }
-  }
-
-  shard.entries = Shard.putEntry(asShardEntries(targetEntries), asShardEntry(entry))
-}
-
-/**
- * Traverse from the passed shard through to the correct shard for the passed
- * key.
- *
- * @param {ShardFetcher} shards
- * @param {API.BatcherShard} shard
- * @param {string} key
- * @returns {Promise<{ shard: API.BatcherShard, key: string }>}
- */
-export const traverse = async (shards, shard, key) => {
-  for (let i = 0; i < shard.entries.length; i++) {
-    const [k, v] = shard.entries[i]
-    if (key <= k) break
-    if (key.startsWith(k) && Array.isArray(v)) {
-      if (Shard.isShardLink(v[0])) {
-        const blk = await shards.get(v[0])
-        const batcher = BatcherShard.create({ base: blk, ...blk.value })
-        shard.entries[i] = [k, v[1] == null ? [batcher] : [batcher, v[1]]]
-        return traverse(shards, batcher, key.slice(k.length))
-      }
-      return traverse(shards, v[0], key.slice(k.length))
-    }
-  }
-  return { shard, key }
-}
-
-/**
- * Encode all altered shards in the batch and return the new root CID and
- * difference blocks.
- *
- * @param {API.BatcherShard} shard
- */
-export const commit = async shard => {
-  /** @type {API.ShardBlockView[]} */
-  const additions = []
-  /** @type {API.ShardBlockView[]} */
-  const removals = []
-
-  /** @type {API.ShardEntry[]} */
-  const entries = []
-  for (const entry of shard.entries) {
-    if (Array.isArray(entry[1]) && !Shard.isShardLink(entry[1][0])) {
-      const result = await commit(entry[1][0])
-      entries.push([
-        entry[0],
-        entry[1][1] == null ? [result.root] : [result.root, entry[1][1]]
-      ])
-      additions.push(...result.additions)
-      removals.push(...result.removals)
-    } else {
-      entries.push(asShardEntry(entry))
-    }
-  }
-
-  const block = await Shard.encodeBlock(Shard.withEntries(entries, shard))
-  additions.push(block)
-
-  if (shard.base && shard.base.cid.toString() === block.cid.toString()) {
-    return { root: block.cid, additions: [], removals: [] }
-  }
-
-  if (shard.base) removals.push(shard.base)
-
-  return { root: block.cid, additions, removals }
-}
-
-/** @param {API.BatcherShardEntry[]} entries */
-const asShardEntries = entries => /** @type {API.ShardEntry[]} */ (entries)
-
-/** @param {API.BatcherShardEntry} entry */
-const asShardEntry = entry => /** @type {API.ShardEntry} */ (entry)
-
-/**
- * @param {API.BlockFetcher} blocks Bucket block storage.
- * @param {API.ShardLink} root CID of the root shard block.
- * @returns {Promise<API.Batcher>}
- */
-export const create = (blocks, root) => Batcher.create({ blocks, link: root })
-
-export class BatchCommittedError extends Error {
-  /**
-   * @param {string} [message]
-   * @param {ErrorOptions} [options]
-   */
-  constructor (message, options) {
-    super(message ?? 'batch already committed', options)
-    this.code = BatchCommittedError.code
-  }
-
-  static code = 'ERR_BATCH_COMMITTED'
-}

package/src/@web3-storage/pail/pail/src/batch/shard.js

@@ -1,13 +0,0 @@
-// eslint-disable-next-line no-unused-vars
-import * as API from './api.js'
-import { configure } from '../shard.js'
-
-/**
- * @param {API.BatcherShardInit} [init]
- * @returns {API.BatcherShard}
- */
-export const create = init => ({
-  base: init?.base,
-  entries: [...(init?.entries ?? [])],
-  ...configure(init)
-})

package/src/@web3-storage/pail/pail/src/block.js

@@ -1,75 +0,0 @@
-// eslint-disable-next-line no-unused-vars
-import * as API from './api.js'
-import { parse } from 'multiformats/link'
-
-/** @implements {API.BlockFetcher} */
-export class MemoryBlockstore {
-  /** @type {Map<string, Uint8Array>} */
-  #blocks = new Map()
-
-  /**
-   * @param {Array<import('multiformats').Block>} [blocks]
-   */
-  constructor (blocks) {
-    if (blocks) {
-      this.#blocks = new Map(blocks.map(b => [b.cid.toString(), b.bytes]))
-    }
-  }
-
-  /** @type {API.BlockFetcher['get']} */
-  async get (cid) {
-    const bytes = this.#blocks.get(cid.toString())
-    if (!bytes) return
-    return { cid, bytes }
-  }
-
-  /**
-   * @param {API.UnknownLink} cid
-   * @param {Uint8Array} bytes
-   */
-  async put (cid, bytes) {
-    this.#blocks.set(cid.toString(), bytes)
-  }
-
-  /**
-   * @param {API.UnknownLink} cid
-   * @param {Uint8Array} bytes
-   */
-  putSync (cid, bytes) {
-    this.#blocks.set(cid.toString(), bytes)
-  }
-
-  /** @param {API.UnknownLink} cid */
-  async delete (cid) {
-    this.#blocks.delete(cid.toString())
-  }
-
-  /** @param {API.UnknownLink} cid */
-  deleteSync (cid) {
-    this.#blocks.delete(cid.toString())
-  }
-
-  * entries () {
-    for (const [str, bytes] of this.#blocks) {
-      yield { cid: parse(str), bytes }
-    }
-  }
-}
-
-export class MultiBlockFetcher {
-  /** @type {API.BlockFetcher[]} */
-  #fetchers
-
-  /** @param {API.BlockFetcher[]} fetchers */
-  constructor (...fetchers) {
-    this.#fetchers = fetchers
-  }
-
-  /** @type {API.BlockFetcher['get']} */
-  async get (link) {
-    for (const f of this.#fetchers) {
-      const v = await f.get(link)
-      if (v) return v
-    }
-  }
-}

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

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

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

@@ -1,12 +0,0 @@
-import { Link, BlockView } from 'multiformats'
-
-export { BlockFetcher } from '../api.js'
-
-export type EventLink<T> = Link<EventView<T>>
-
-export interface EventView<T> {
-  parents: EventLink<T>[]
-  data: T
-}
-
-export interface EventBlockView<T> extends BlockView<EventView<T>> {}

package/src/@web3-storage/pail/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 "@fireproof/vendor/@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/pail/src/crdt/api.js

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