@tanstack/redact 0.0.21 → 0.1.0

package/src/dom/features/activity/full.ts

@@ -0,0 +1,166 @@
+import { FiberTag, type Fiber } from '../../../core'
+import { REACT_ACTIVITY_TYPE } from '../../../react/activity'
+import { onCommitRollback, queueMutation } from '../../commit'
+import { retainedEffects as effects, inSuspensePrimary, setLayoutDisconnected, walkRetained as walk } from '../../retained-effects'
+import {
+  attachRef,
+  childrenToArray,
+  detachRef,
+  enqueueEffect,
+  findRoot,
+  flushFiberCommits,
+  getCurrentRoot,
+  handleCommitError,
+  installCapability,
+  reconcileChildren,
+  registerRenderer,
+  registerTypeMatcher,
+  scheduleLifecycle,
+  scheduleUpdate,
+} from '../../reconcile'
+
+// Retain effect descriptions, not subscriptions, while a subtree is hidden.
+// Weak keys keep this bookkeeping out of fibers that do not use Activity.
+const disconnected = new WeakSet<Fiber>()
+const hiddenDoms = new WeakSet<Fiber>()
+
+function setMembership(set: WeakSet<Fiber>, fiber: Fiber, present: boolean): boolean {
+  const previous = set.has(fiber)
+  if (previous === present) return previous
+  onCommitRollback(() => { if (previous) set.add(fiber); else set.delete(fiber) })
+  if (present) set.add(fiber)
+  else set.delete(fiber)
+  return previous
+}
+
+function isHidden(fiber: Fiber): boolean {
+  if (!(fiber.root ?? findRoot(fiber))?.a) return false
+  for (let parent: Fiber | null = fiber; parent; parent = parent.parent) {
+    if (parent.tag === FiberTag.Activity && parent.pp?.mode === 'hidden') return true
+  }
+  return false
+}
+
+function report(fiber: Fiber, fn: () => void): void {
+  try { fn() } catch (error) { handleCommitError(fiber, error) }
+}
+
+function disconnect(fiber: Fiber): void {
+  if (disconnected.has(fiber)) return
+  setMembership(disconnected, fiber, true)
+  queueMutation(() => {
+    // Insertion effects remain connected, just as they do in React.
+    const insertion = new Set<() => void>()
+    for (const [hook, effect] of effects.get(fiber) ?? []) {
+      if (effect.t === 2 && hook.c) insertion.add(hook.c)
+    }
+    if (fiber.cu) {
+      const keep = fiber.cu.filter(cleanup => insertion.has(cleanup))
+      for (const cleanup of fiber.cu) {
+        if (!insertion.has(cleanup)) report(fiber, cleanup)
+      }
+      fiber.cu = keep.length ? keep : null
+    }
+    for (const [hook, effect] of effects.get(fiber) ?? []) {
+      if (effect.t !== 2) hook.c = null
+    }
+    detachRef(fiber.cr ?? fiber.ref)
+    fiber.cr = null
+    fiber.rc = null
+    const instance = fiber.sn?._fiber === fiber ? fiber.sn : null
+    if (!fiber.ld && instance?.componentWillUnmount) {
+      const props = instance.props, state = instance.state, committed = fiber.ms?.c
+      if (committed) { instance.props = committed.props; instance.state = committed.state }
+      try { report(fiber, () => instance.componentWillUnmount()) }
+      finally { instance.props = props; instance.state = state }
+    }
+  })
+}
+
+function prepare(fiber: Fiber): void {
+  if (!isHidden(fiber) || disconnected.has(fiber)) return
+  if (fiber.mp == null) setMembership(disconnected, fiber, true)
+  else disconnect(fiber)
+}
+
+function needsHiddenDom(fiber: Fiber): boolean {
+  for (let parent = fiber.parent; parent; parent = parent.parent) {
+    if (parent.tag === FiberTag.Activity && parent.pp?.mode === 'hidden') return true
+    if (parent.tag === FiberTag.Host) return false
+    // A portal starts a new DOM tree, but keeps the parent's Activity state.
+    if (parent.tag === FiberTag.Portal) return isHidden(parent)
+  }
+  return false
+}
+
+function syncDom(fiber: Fiber): void {
+  if (!(fiber.root ?? findRoot(fiber))?.a) return
+  if (!fiber.dom || (fiber.tag !== FiberTag.Host && fiber.tag !== FiberTag.Text)) return
+  if (needsHiddenDom(fiber)) {
+    setMembership(hiddenDoms, fiber, true)
+    queueMutation(() => {
+      if (fiber.tag === FiberTag.Text) fiber.dom!.nodeValue = ''
+      else (fiber.dom as HTMLElement).style.setProperty('display', 'none', 'important')
+    })
+  } else if (setMembership(hiddenDoms, fiber, false)) {
+    // A Suspense fallback can remain active after its Activity is revealed.
+    // Its preserved primary DOM must stay hidden until that boundary resumes.
+    for (let parent = fiber.parent; parent; parent = parent.parent) {
+      if (parent.tag === FiberTag.Suspense && parent.ms?.d?.some(([node]: [Node, string]) => node === fiber.dom)) return
+    }
+    const props = fiber.pp
+    queueMutation(() => {
+      if (fiber.tag === FiberTag.Text) fiber.dom!.nodeValue = props
+      else {
+        const display = props?.style?.display
+        ;(fiber.dom as HTMLElement).style.display = display == null || typeof display === 'boolean' ? '' : ('' + display).trim()
+      }
+    })
+  }
+}
+
+function reconnect(fiber: Fiber): void {
+  syncDom(fiber)
+  if (isHidden(fiber) || inSuspensePrimary(fiber) || !setMembership(disconnected, fiber, false)) return
+  setLayoutDisconnected(fiber, false)
+  const instance = fiber.sn?._fiber === fiber ? fiber.sn : null
+  if (fiber.tag === FiberTag.Host || fiber.tag === FiberTag.Resource) attachRef(fiber, fiber.dom)
+  else if (instance || fiber.tag === FiberTag.Fragment) attachRef(fiber, fiber.sn)
+  for (const effect of effects.get(fiber)?.values() ?? []) {
+    if (effect.t !== 2) enqueueEffect(fiber, effect)
+  }
+  if (instance?.componentDidMount) {
+    scheduleLifecycle(fiber, () => instance.componentDidMount())
+  }
+  flushFiberCommits(fiber)
+}
+
+function finish(fiber: Fiber): void {
+  if (fiber.tag === FiberTag.Suspense && (fiber.root ?? findRoot(fiber))?.a) walk(fiber, reconnect, true)
+  else syncDom(fiber)
+}
+
+function renderActivity(fiber: Fiber, domParent: Node, anchor: Node | null): void {
+  const root = fiber.root ?? findRoot(fiber)
+  if (root) root.a = true
+  const props = fiber.pp ?? {}
+  // Hidden content is absent from server HTML. Mount it after hydration so it
+  // cannot consume a following visible sibling's hydration cursor.
+  if (getCurrentRoot()?.h && props.mode === 'hidden' && !fiber.mp) {
+    fiber.mp = props
+    queueMicrotask(() => scheduleUpdate(fiber))
+    return
+  }
+  if (isHidden(fiber)) walk(fiber, prepare)
+  else walk(fiber, syncDom)
+  reconcileChildren(fiber, childrenToArray(props.children), domParent, anchor)
+  walk(fiber, reconnect, true)
+  fiber.mp = props
+}
+
+installCapability('isActivityHidden', isHidden)
+installCapability('activityIsDisconnected', fiber => disconnected.has(fiber))
+installCapability('prepareActivityFiber', prepare)
+installCapability('syncActivity', finish)
+registerTypeMatcher(type => type === REACT_ACTIVITY_TYPE ? FiberTag.Activity : null)
+registerRenderer(FiberTag.Activity, renderActivity)

package/src/dom/features/activity/index.ts

@@ -0,0 +1 @@
+export * from './full'

package/src/dom/features/activity/stub.ts

@@ -0,0 +1,14 @@
+import { FiberTag, type Fiber } from '../../../core'
+import { REACT_ACTIVITY_TYPE } from '../../../react/activity'
+import { childrenToArray, reconcileChildren, registerRenderer, registerTypeMatcher } from '../../reconcile'
+
+// Explicit small-preset downgrade: hidden children unmount instead of being
+// retained. Showing them again creates fresh state, DOM, effects, and refs.
+function renderActivity(fiber: Fiber, parent: Node, anchor: Node | null): void {
+  const props = fiber.pp ?? {}
+  reconcileChildren(fiber, props.mode === 'hidden' ? [] : childrenToArray(props.children), parent, anchor)
+  fiber.mp = props
+}
+
+registerTypeMatcher(type => type === REACT_ACTIVITY_TYPE ? FiberTag.Activity : null)
+registerRenderer(FiberTag.Activity, renderActivity)

package/src/dom/features/class/full.ts

@@ -1,4 +1,5 @@
 import { FiberTag, type Fiber, type ReactNode } from '../../../core'
+import { checkpointCommit, rewindCommit, queueBeforeMutation, queueMutation } from '../../commit'
 import {
   registerRenderer,
   reconcileChildren,
@@ -8,17 +9,30 @@ import {
   isThenable,
   handleSuspended,
   handleErrorInRender,
+  readContext,
+  attachRef,
+  syncRefIfChanged,
+  isActivityHidden,
+  layoutIsDisconnected,
+  RenderErrorCapture,
+  handleCommitError,
 } from '../../reconcile'
 
 function renderClass(fiber: Fiber, domParent: Node, anchor: Node | null): void {
+  fiber.cx?.clear()
   const Ctor = fiber.type as any
   let instance = fiber.sn
   const props = fiber.pp ?? {}
   const isNew = !instance
+  const previous = fiber.ms?.c
+  let didRender = true
+  let captured = fiber.ms?.error instanceof RenderErrorCapture ? fiber.ms.error as RenderErrorCapture : undefined
+  if (captured) delete fiber.ms.error
 
   // Class contextType: read the current value of the subscribed context so
   // `this.context` reflects the nearest Provider. Evaluated every render.
-  const ctxValue = Ctor.contextType ? Ctor.contextType._currentValue : undefined
+  const ctxValue = Ctor.contextType ? readContext(fiber, Ctor.contextType) : undefined
+  const contextChanged = instance && !Object.is(instance.context, ctxValue)
 
   if (isNew) {
     instance = new Ctor(props, ctxValue)
@@ -47,39 +61,31 @@ function renderClass(fiber: Fiber, domParent: Node, anchor: Node | null): void {
       if (d) instance.state = { ...instance.state, ...d }
     }
   } else {
-    const prevProps = instance.props
-    const prevState = instance.state
     // Refresh context on every render — Providers higher up may have changed.
     instance.context = ctxValue
     if (Ctor.getDerivedStateFromProps) {
       const d = Ctor.getDerivedStateFromProps(props, instance.state)
       if (d) instance.state = { ...instance.state, ...d }
     }
-    if (instance.shouldComponentUpdate) {
+    if (!captured && instance.shouldComponentUpdate && !contextChanged) {
       if (!instance.shouldComponentUpdate(props, instance.state, instance.context)) {
-        instance.props = props
-        fiber.mp = props
-        // Still need to render children with previous output
-        if (fiber.ms?.r) {
-          reconcileChildren(fiber, childrenToArray(fiber.ms.r), domParent, anchor)
-        }
-        return
+        didRender = false
       }
     }
     instance.props = props
-    // New snapshot must win over any stale one from a previous render —
-    // otherwise componentDidUpdate keeps seeing the original props and can
-    // ping-pong setState forever.
-    fiber.ms = { ...(fiber.ms ?? {}), p: prevProps, s: prevState }
+  }
+  if (captured && Ctor.getDerivedStateFromError) {
+    const update = Ctor.getDerivedStateFromError(captured.error)
+    if (update != null) instance.state = { ...instance.state, ...update }
   }
 
   let rendered: ReactNode
   try {
-    rendered = instance.render()
+    rendered = captured && !Ctor.getDerivedStateFromError ? null : didRender ? instance.render() : fiber.ms?.r
   } catch (e: any) {
     if (isThenable(e)) {
       handleSuspended(fiber, e)
-      rendered = null
+      return
     } else {
       handleErrorInRender(fiber, e)
       return
@@ -87,24 +93,62 @@ function renderClass(fiber: Fiber, domParent: Node, anchor: Node | null): void {
   }
   fiber.ms = { ...(fiber.ms ?? {}), r: rendered }
 
-  reconcileChildren(fiber, childrenToArray(rendered), domParent, anchor)
+  const canCatch = Ctor.getDerivedStateFromError || instance.componentDidCatch
+  if (canCatch) fiber.ms.b = Ctor
+  if (canCatch && fiber.root) fiber.root.eb = true
+  const checkpoint = canCatch ? checkpointCommit(fiber) : -1
+  try {
+    reconcileChildren(fiber, childrenToArray(rendered), domParent, anchor)
+  } catch (error) {
+    if (!(error instanceof RenderErrorCapture) || error.boundary !== fiber) throw error
+    rewindCommit(checkpoint)
+    captured = error
+    didRender = true
+    if (Ctor.getDerivedStateFromError) {
+      const update = Ctor.getDerivedStateFromError(error.error)
+      if (update != null) instance.state = { ...instance.state, ...update }
+      try { rendered = instance.render() } catch (fallbackError) {
+        handleErrorInRender(fiber, fallbackError)
+        return
+      }
+    } else rendered = null
+    fiber.ms = { ...(fiber.ms ?? {}), r: rendered }
+    reconcileChildren(fiber, childrenToArray(rendered), domParent, anchor)
+  }
   fiber.mp = props
+  const state = instance.state
+  queueMutation(() => { fiber.ms.c = { props, state } })
+
+  if (isNew) attachRef(fiber, instance)
+  else syncRefIfChanged(fiber, instance)
 
   // Schedule lifecycle
   if (isNew) {
-    if (instance.componentDidMount || instance.componentWillUnmount) {
-      scheduleLifecycle(fiber, () => {
-        // An abandoned render never mounted, so it has no unmount lifecycle.
-        if (instance.componentWillUnmount) {
-          fiber.cu ||= []
-          fiber.cu.push(() => instance.componentWillUnmount())
+    if (instance.componentDidMount) {
+      scheduleLifecycle(fiber, () => instance.componentDidMount())
+    }
+  } else if (previous && didRender) {
+    let snapshot: any
+    if (instance.getSnapshotBeforeUpdate && !layoutIsDisconnected(fiber)) {
+      queueBeforeMutation(() => {
+        if (!fiber.um && !fiber.pd && !isActivityHidden(fiber) && !layoutIsDisconnected(fiber)) {
+          try { snapshot = instance.getSnapshotBeforeUpdate(previous.props, previous.state) }
+          catch (error) { handleCommitError(fiber, error) }
         }
-        instance.componentDidMount?.()
       })
     }
-  } else if (instance.componentDidUpdate) {
-    const { p, s } = fiber.ms ?? {}
-    scheduleLifecycle(fiber, () => instance.componentDidUpdate(p, s))
+    if (instance.componentDidUpdate) {
+      scheduleLifecycle(fiber, () => instance.componentDidUpdate(previous.props, previous.state, snapshot))
+    }
+  }
+  if (captured) {
+    const error = captured.error
+    const info = { componentStack: captured.stack }
+    scheduleLifecycle(fiber, () => {
+      try { fiber.root?.ce?.(error, { ...info, errorBoundary: instance }) }
+      catch (callbackError) { setTimeout(() => { throw callbackError }) }
+      instance.componentDidCatch?.(error, info)
+    })
   }
 }
 

package/src/dom/features/context/full.ts

@@ -6,9 +6,14 @@ import {
   installCapability,
   reconcileChildren,
   childrenToArray,
+  renderFiber,
+  getHostParent,
+  getAnchor,
 } from '../../reconcile'
 
-function realReadContext(fiber: Fiber, ctx: any): any {
+let changingProviders = 0
+
+function contextValue(fiber: Fiber, ctx: any): any {
   let p: Fiber | null = fiber.parent
   while (p) {
     if (p.tag === FiberTag.Provider && (p.type as any)._context === ctx) {
@@ -19,15 +24,71 @@ function realReadContext(fiber: Fiber, ctx: any): any {
   return ctx._currentValue
 }
 
+function remember(fiber: Fiber, ctx: any, value: any): void {
+  ;(fiber.cx ??= new Map()).set(ctx, value)
+}
+
+function realReadContext(fiber: Fiber, ctx: any): any {
+  const value = contextValue(fiber, ctx)
+  remember(fiber, ctx, value)
+  // Initial suspended attempts are discarded. Keep their external context
+  // reads on the boundary so a provider can retry them before a promise settles.
+  let child = fiber
+  let p = fiber.parent
+  while (p) {
+    if (p.tag === FiberTag.Provider && p.type._context === ctx) break
+    if (p.tag === FiberTag.Suspense && p.ms?.f !== child) remember(p, ctx, value)
+    child = p
+    p = p.parent
+  }
+  return value
+}
+
+export function ownContextChanged(fiber: Fiber): boolean {
+  if (!changingProviders) return false
+  const reads = fiber.cx
+  if (reads) {
+    for (const [ctx, value] of reads) {
+      if (!Object.is(value, contextValue(fiber, ctx))) return true
+    }
+  }
+  return false
+}
+
+export function hasContextChanged(fiber: Fiber, includeFallback = true): boolean {
+  if (!changingProviders) return false
+  if (ownContextChanged(fiber)) return true
+  let child = fiber.child
+  while (child) {
+    if (hasContextChanged(child)) return true
+    child = child.sibling
+  }
+  return includeFallback && fiber.tag === FiberTag.Suspense && !!fiber.ms?.f && hasContextChanged(fiber.ms.f)
+}
+
+export function renderContextConsumers(fiber: Fiber): void {
+  if (!changingProviders) return
+  let child = fiber.child
+  while (child) {
+    if (child.tag === FiberTag.Suspense ? hasContextChanged(child) : ownContextChanged(child)) {
+      const domParent = getHostParent(child)
+      renderFiber(child, domParent, getAnchor(child, domParent))
+    } else {
+      renderContextConsumers(child)
+    }
+    child = child.sibling
+  }
+}
+
 function renderProvider(fiber: Fiber, domParent: Node, anchor: Node | null): void {
   const ctx = (fiber.type as any)._context
   const props = fiber.pp ?? {}
-  const prevValue = ctx._currentValue
-  ctx._currentValue = props.value
+  const changed = fiber.mp && !Object.is(fiber.mp.value, props.value)
+  if (changed) changingProviders++
   try {
     reconcileChildren(fiber, childrenToArray(props.children), domParent, anchor)
   } finally {
-    ctx._currentValue = prevValue
+    if (changed) changingProviders--
   }
   // Also store the value on the fiber so descendants rendering later (via updates)
   // can read through by walking up.
@@ -36,6 +97,7 @@ function renderProvider(fiber: Fiber, domParent: Node, anchor: Node | null): voi
 }
 
 function renderConsumer(fiber: Fiber, domParent: Node, anchor: Node | null): void {
+  fiber.cx?.clear()
   const ctx = (fiber.type as any)._context
   const props = fiber.pp ?? {}
   const children = props.children

package/src/dom/features/context/stub.ts

@@ -7,6 +7,12 @@ import {
   childrenToArray,
 } from '../../reconcile'
 
+export function hasContextChanged(_fiber: Fiber, _includeFallback = true): boolean {
+  return false
+}
+export const ownContextChanged = hasContextChanged
+export function renderContextConsumers(_fiber: Fiber): void {}
+
 // Stub: Context feature disabled. Provider elements render as Fragments
 // (value is never propagated — descendants see only the Context's default).
 // Consumer elements still invoke their function-children with the default

package/src/dom/features/forward-ref/full.ts

@@ -1,5 +1,5 @@
 import { FiberTag, type Fiber, type ReactNode } from '../../../core'
-import { ReactSharedInternals, REACT_FORWARD_REF_TYPE } from '../../../react'
+import { REACT_FORWARD_REF_TYPE } from '../../../react'
 import {
   registerRenderer,
   registerTypeMatcher,
@@ -8,42 +8,32 @@ import {
   isThenable,
   handleSuspended,
   handleErrorInRender,
+  getForceRerenderingFiber,
 } from '../../reconcile'
-import { makeDispatcher } from '../../dispatcher'
+import { HOOK_BAILOUT, renderWithHooks } from '../../dispatcher'
 
 function renderForwardRef(fiber: Fiber, domParent: Node, anchor: Node | null): void {
+  const canBail = fiber === getForceRerenderingFiber() && fiber.pp === fiber.mp
+  fiber.cx?.clear()
   const props = fiber.pp ?? {}
   const render = (fiber.type as any).render
   const ref = fiber.ref ?? (props.ref ?? null)
 
-  const prevDispatcher = ReactSharedInternals.H
-  const prevFiber = ReactSharedInternals.F
-  const prevHook = ReactSharedInternals.K
-  const prevIndex = ReactSharedInternals.I
-  ReactSharedInternals.H = makeDispatcher()
-  ReactSharedInternals.F = fiber
-  ReactSharedInternals.K = null
-  ReactSharedInternals.I = 0
-
-  let rendered: ReactNode
+  let rendered: ReactNode | typeof HOOK_BAILOUT
   try {
     const { ref: _omit, ...rest } = props
-    rendered = render(rest, ref)
+    rendered = renderWithHooks(fiber, render, rest, ref, canBail)
   } catch (e: any) {
     if (isThenable(e)) {
       handleSuspended(fiber, e)
-      rendered = null
+      return
     } else {
       handleErrorInRender(fiber, e)
       return
     }
-  } finally {
-    ReactSharedInternals.H = prevDispatcher
-    ReactSharedInternals.F = prevFiber
-    ReactSharedInternals.K = prevHook
-    ReactSharedInternals.I = prevIndex
   }
 
+  if (rendered === HOOK_BAILOUT) return
   reconcileChildren(fiber, childrenToArray(rendered), domParent, anchor)
   fiber.mp = props
 }

package/src/dom/features/fragment-refs/index.ts

@@ -0,0 +1 @@
+export { createFragmentInstance, updateFragmentHost, refreshFragmentInstances } from '../../fragment-instance'

package/src/dom/features/fragment-refs/stub.ts

@@ -0,0 +1,3 @@
+export function createFragmentInstance(_fiber: unknown): any { return null }
+export function updateFragmentHost(_fiber: unknown, _adding: boolean): void {}
+export function refreshFragmentInstances(_root: unknown): void {}