bruh 1.13.1 → 2.0.0-beta.1

package/src/reactive/index.mjs

@@ -1,160 +0,0 @@
-export const isReactive = Symbol.for("bruh reactive")
-
-// A super simple and performant reactive value implementation
-export class SimpleReactive {
-  [isReactive] = true
-
-  #value
-  #reactions = new Set()
-
-  constructor(value) {
-    this.#value = value
-  }
-
-  get value() {
-    return this.#value
-  }
-
-  set value(newValue) {
-    if (newValue === this.#value)
-      return
-
-    this.#value = newValue
-    for (const reaction of this.#reactions)
-      reaction()
-  }
-
-  addReaction(reaction) {
-    this.#reactions.add(reaction)
-
-    return () =>
-      this.#reactions.delete(reaction)
-  }
-}
-
-// A reactive implementation for building functional reactive graphs
-// Ensures state consistency, minimal node updates, and transparent update batching
-export class FunctionalReactive {
-  [isReactive] = true
-
-  #value
-  #reactions = new Set()
-
-  // For derived nodes, f is the derivation function
-  #f
-  // Source nodes are 0 deep in the derivation graph
-  // This is for topological sort
-  #depth = 0
-  // All nodes have a set of derivatives that update when the node changes
-  #derivatives = new Set()
-
-  // Keep track of all the pending changes from the value setter
-  static #settersQueue = new Map()
-  // A queue of derivatives to potentially update, sorted into sets by depth
-  // This starts with depth 1 and can potentially have holes
-  static #derivativesQueue = []
-  // A queue of reactions to run after the graph is fully updated
-  static #reactionsQueue = []
-
-  constructor(x, f) {
-    if (!f) {
-      this.#value = x
-      return
-    }
-
-    this.#value = f()
-    this.#f = f
-    this.#depth = Math.max(...x.map(d => d.#depth)) + 1
-
-    x.forEach(d => d.#derivatives.add(this))
-  }
-
-  get value() {
-    // If there are any pending updates
-    if (FunctionalReactive.#settersQueue.size) {
-      // Heuristic quick invalidation for derived nodes
-      // Apply updates now, it's ok that there's already a microtask queued for this
-      if (this.#depth !== 0)
-        FunctionalReactive.applyUpdates()
-      // If this is a source node that was updated, just return that
-      // new value without actually updating any derived nodes yet
-      else if (FunctionalReactive.#settersQueue.has(this))
-        return FunctionalReactive.#settersQueue.get(this)
-    }
-
-    return this.#value
-  }
-
-  set value(newValue) {
-    // Only allow source nodes to be directly updated
-    if (this.#depth !== 0)
-      return
-
-    // Unless asked for earlier, these updates are just queued up until the microtasks run
-    if (!FunctionalReactive.#settersQueue.size)
-      queueMicrotask(FunctionalReactive.applyUpdates)
-
-    FunctionalReactive.#settersQueue.set(this, newValue)
-  }
-
-  addReaction(reaction) {
-    this.#reactions.add(reaction)
-
-    return () =>
-      this.#reactions.delete(reaction)
-  }
-
-  // Apply an update for a node and queue its derivatives if it actually changed
-  #applyUpdate(newValue) {
-    if (newValue === this.#value)
-      return
-
-    this.#value = newValue
-    FunctionalReactive.#reactionsQueue.push(...this.#reactions)
-
-    const queue = FunctionalReactive.#derivativesQueue
-    for (const derivative of this.#derivatives) {
-      const depth = derivative.#depth
-      if (!queue[depth])
-        queue[depth] = new Set()
-
-      queue[depth].add(derivative)
-    }
-  }
-
-  // Apply pending updates from actually changed source nodes
-  static applyUpdates() {
-    if (!FunctionalReactive.#settersQueue.size)
-      return
-
-    // Bootstrap by applying the updates from the pending setters
-    for (const [sourceNode, newValue] of FunctionalReactive.#settersQueue.entries())
-      sourceNode.#applyUpdate(newValue)
-    FunctionalReactive.#settersQueue.clear()
-
-    // Iterate down the depths, ignoring holes
-    // Note that both the queue (Array) and each depth Set iterators update as items are added
-    for (const depthSet of FunctionalReactive.#derivativesQueue) if (depthSet)
-      for (const derivative of depthSet)
-        derivative.#applyUpdate(derivative.#f())
-    FunctionalReactive.#derivativesQueue.length = 0
-
-    // Call all reactions now that the graph has a fully consistent state
-    for (const reaction of FunctionalReactive.#reactionsQueue)
-      reaction()
-    FunctionalReactive.#reactionsQueue.length = 0
-  }
-}
-
-// A little convenience function
-export const r = (x, f) => new FunctionalReactive(x, f)
-
-// Do something with a value, updating if it is reactive
-export const reactiveDo = (x, f) => {
-  if (x?.[isReactive]) {
-    f(x.value)
-    return x.addReaction(() => f(x.value))
-  }
-
-  f(x)
-}

package/src/util/index.mjs

@@ -1,42 +0,0 @@
-// Create a pipeline with an initial value and a series of functions
-export const pipe = (x, ...fs) =>
-  fs.reduce((y, f) => f(y), x)
-
-// Dispatch a custom event to (capturing) and from (bubbling) a target (usually a DOM node)
-// Returns false if the event was cancelled (preventDefault()) and true otherwise
-// Note that this is synchronous
-export const dispatch = (target, type, options) =>
-  target.dispatchEvent(
-    // Default to behave like most DOM events
-    new CustomEvent(type, {
-      bubbles: true,
-      cancelable: true,
-      composed: true,
-      ...options
-    })
-  )
-
-// Inspired by https://antfu.me/posts/destructuring-with-object-or-array#take-away
-// Creates an object that is both destructable with {...} and [...]
-// Useful for writing library functions à la react-use & vueuse
-export const createDestructable = (object, iterable) => {
-  const destructable = {
-    ...object,
-    [Symbol.iterator]: () => iterable[Symbol.iterator]()
-  }
-
-  Object.defineProperty(destructable, Symbol.iterator, {
-    enumerable: false
-  })
-
-  return destructable
-}
-
-// Creates an object (as a Proxy) that acts as a function
-// So functionAsObject(f).property is equivalent to f("property")
-// This is can be useful when combined with destructuring syntax, e.g.:
-// const { html, head, title, body, main, h1, p } = functionAsObject(e)
-export const functionAsObject = f =>
-  new Proxy({}, {
-    get: (_, property) => f(property)
-  })