@tanstack/redact 0.0.1

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

@@ -0,0 +1,42 @@
+import { FiberTag, type Fiber } from '../../../core'
+import {
+  REACT_FORWARD_REF_TYPE,
+  REACT_MEMO_TYPE,
+  REACT_LAZY_TYPE,
+} from '../../../react'
+import { registerRenderer, registerTypeMatcher, renderFiber } from '../../reconcile'
+
+// Stub: Memo feature disabled. `memo(Component)` still works — the element
+// renders — but without the prop-equality gate, so every parent rerender
+// passes through to the inner component. `shallowEqual` and the
+// forceRerenderingFiber read are stripped.
+function renderMemoStub(fiber: Fiber, domParent: Node, anchor: Node | null): void {
+  const { type } = fiber.type as any
+
+  let innerTag: FiberTag
+  if (typeof type === 'function') {
+    innerTag = type.prototype?.isReactComponent ? FiberTag.Class : FiberTag.Function
+  } else if (type && typeof type === 'object') {
+    const m = (type as any).$$typeof
+    if (m === REACT_FORWARD_REF_TYPE) innerTag = FiberTag.ForwardRef
+    else if (m === REACT_MEMO_TYPE) innerTag = FiberTag.Memo
+    else if (m === REACT_LAZY_TYPE) innerTag = FiberTag.Lazy
+    else innerTag = FiberTag.Fragment
+  } else {
+    innerTag = FiberTag.Fragment
+  }
+
+  const savedTag = fiber.tag
+  const savedType = fiber.type
+  fiber.tag = innerTag
+  fiber.type = type
+  try {
+    renderFiber(fiber, domParent, anchor)
+  } finally {
+    fiber.tag = savedTag
+    fiber.type = savedType
+  }
+}
+
+registerTypeMatcher((_type, marker) => (marker === REACT_MEMO_TYPE ? FiberTag.Memo : null))
+registerRenderer(FiberTag.Memo, renderMemoStub)

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

@@ -0,0 +1,22 @@
+import { FiberTag, type Fiber, type ReactNode } from '../../../core'
+import { REACT_PORTAL_TYPE } from '../../../react'
+import {
+  registerRenderer,
+  registerTypeMatcher,
+  registerElementMarker,
+  reconcileChildren,
+  childrenToArray,
+} from '../../reconcile'
+
+function renderPortal(fiber: Fiber, _domParent: Node, _anchor: Node | null): void {
+  const { children, container } = fiber.pendingProps as {
+    children: ReactNode
+    container: Element
+  }
+  reconcileChildren(fiber, childrenToArray(children), container, null)
+  fiber.memoizedProps = fiber.pendingProps
+}
+
+registerElementMarker(REACT_PORTAL_TYPE)
+registerTypeMatcher((type) => (type === REACT_PORTAL_TYPE ? FiberTag.Portal : null))
+registerRenderer(FiberTag.Portal, renderPortal)

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

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

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

@@ -0,0 +1,11 @@
+import { FiberTag } from '../../../core'
+import { REACT_PORTAL_TYPE } from '../../../react'
+import { registerTypeMatcher, registerElementMarker } from '../../reconcile'
+
+// Stub: Portal feature disabled. Portal elements still flow through JSX
+// (otherwise they'd be silently dropped by child normalization), but render
+// in place as a Fragment — the `container` prop is ignored. No Portal
+// renderer is registered, so the `renderPortal` function and its deps don't
+// ship in builds that select this stub.
+registerElementMarker(REACT_PORTAL_TYPE)
+registerTypeMatcher((type) => (type === REACT_PORTAL_TYPE ? FiberTag.Fragment : null))

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

@@ -0,0 +1,191 @@
+import { FiberTag, type Fiber } from '../../../core'
+import { REACT_SUSPENSE_TYPE } from '../../../react'
+import {
+  registerRenderer,
+  registerTypeMatcher,
+  installCapability,
+  reconcileChildren,
+  childrenToArray,
+  scheduleUpdate,
+  unmountAllChildren,
+  findRoot,
+  runEffects,
+  getCurrentRoot,
+  withCurrentRoot,
+} from '../../reconcile'
+import {
+  HydrationCursor,
+  setHydrationCursor,
+  clearHydrationCursor,
+  advanceCursorPast,
+  tryConsumeBoundary,
+} from '../hydration'
+
+const suspendHandlerStack: Array<(t: Promise<any>) => void> = []
+
+function realHandleSuspended(fiber: Fiber, thenable: Promise<any>): void {
+  const handler = suspendHandlerStack[suspendHandlerStack.length - 1]
+  if (handler) {
+    handler(thenable)
+    return
+  }
+  // Fallback: schedule re-render when promise settles
+  thenable.then(
+    () => scheduleUpdate(fiber),
+    () => scheduleUpdate(fiber),
+  )
+}
+
+function renderSuspense(fiber: Fiber, domParent: Node, anchor: Node | null): void {
+  const props = fiber.pendingProps ?? {}
+  const state = (fiber.memoizedState ??= { suspended: false, pending: null as Promise<any> | null })
+
+  // Streaming hydration: if the next DOM node is a server-emitted boundary
+  // marker, route through the boundary-aware hydration path.
+  const root = getCurrentRoot()
+  if (root?.hydrating && fiber.parent && !state.hydrated) {
+    const boundary = tryConsumeBoundary(fiber.parent)
+    if (boundary) {
+      hydrateSuspenseBoundary(fiber, props, boundary, domParent, anchor)
+      state.hydrated = true
+      return
+    }
+  }
+
+  // A descendant Lazy deferred its hydration (see renderLazy's hydrating
+  // branch). Its SSR-rendered content is still in the DOM and cursor-bound
+  // via the Lazy fiber — we just haven't swapped it into a fiber subtree
+  // yet. Until the Lazy's resume fires, skip our own tryChildren pass so
+  // an unrelated re-render can't accidentally flip us into the suspended
+  // path and mount a duplicate fallback on top of the SSR content.
+  if ((state as any)._awaitingLazyHydration) {
+    fiber.memoizedProps = props
+    return
+  }
+
+  const tryChildren = () => {
+    reconcileChildren(fiber, childrenToArray(props.children), domParent, anchor)
+  }
+
+  if (state.suspended && state.pending) {
+    // Render fallback while waiting; pending promise will reschedule
+    reconcileChildren(fiber, childrenToArray(props.fallback), domParent, anchor)
+    fiber.memoizedProps = props
+    return
+  }
+
+  // Attempt children — suspension is handled by the pushed handler below
+  const savedHandler = suspendHandlerStack[suspendHandlerStack.length - 1]
+  suspendHandlerStack.push((thenable) => {
+    state.suspended = true
+    state.pending = thenable
+    thenable.then(
+      () => {
+        state.suspended = false
+        state.pending = null
+        scheduleUpdate(fiber)
+      },
+      () => {
+        state.suspended = false
+        state.pending = null
+        scheduleUpdate(fiber)
+      },
+    )
+  })
+  try {
+    tryChildren()
+  } finally {
+    suspendHandlerStack.pop()
+    void savedHandler
+  }
+
+  if (state.suspended) {
+    // Replace children with fallback
+    unmountAllChildren(fiber, domParent)
+    reconcileChildren(fiber, childrenToArray(props.fallback), domParent, anchor)
+  }
+  fiber.memoizedProps = props
+}
+
+function hydrateSuspenseBoundary(
+  fiber: Fiber,
+  props: any,
+  boundary: { kind: 'pending' | 'resolved'; id: number; startMark: Comment; endMark: Comment },
+  domParent: Node,
+  anchor: Node | null,
+): void {
+  const { kind, id, startMark, endMark } = boundary
+  // Record the boundary shape so we can re-hydrate on reveal.
+  fiber.memoizedState = {
+    suspended: false,
+    pending: null,
+    hydrated: true,
+    boundaryId: id,
+    startMark,
+    endMark,
+    realChildren: props.children,
+  }
+
+  if (kind === 'resolved') {
+    // Real DOM is inline between startMark and endMark. Hydrate into it.
+    const cursor = new HydrationCursor(startMark.parentNode!, startMark.nextSibling, endMark)
+    setHydrationCursor(fiber, cursor)
+    reconcileChildren(fiber, childrenToArray(props.children), domParent, anchor)
+    clearHydrationCursor(fiber)
+    advanceCursorPast(fiber.parent!, endMark)
+    fiber.memoizedProps = props
+    return
+  }
+
+  // Pending: fallback DOM lives inside <div id="B:ID">. Hydrate the fallback
+  // React subtree against that div's children.
+  const bDiv = (document as Document).getElementById(`B:${id}`)
+  if (bDiv) {
+    const cursor = new HydrationCursor(bDiv)
+    setHydrationCursor(fiber, cursor)
+    reconcileChildren(fiber, childrenToArray(props.fallback), domParent, anchor)
+    clearHydrationCursor(fiber)
+  } else {
+    // Couldn't find fallback container — render fresh (non-adopting)
+    reconcileChildren(fiber, childrenToArray(props.fallback), domParent, anchor)
+  }
+  advanceCursorPast(fiber.parent!, endMark)
+
+  // Register for server-streamed reveal (HTML chunks + $RC calls).
+  const win = globalThis as any
+  if (typeof win.$RH === 'function') {
+    win.$RH(id, () => rehydrateBoundary(fiber))
+  }
+  // If the inline runtime isn't present, nothing external will mark us dirty.
+
+  fiber.memoizedProps = props
+}
+
+function rehydrateBoundary(fiber: Fiber): void {
+  const state = fiber.memoizedState
+  if (!state || !state.startMark || !state.endMark) return
+
+  const root = findRoot(fiber)
+  if (!root) return
+  const parent = state.startMark.parentNode as Node
+  if (!parent) return
+
+  // Unmount existing fallback subtree. Its DOM has already been removed by $RC
+  // (or at least its container); unmounting here cleans up fibers + effects.
+  withCurrentRoot(root, () => {
+    unmountAllChildren(fiber, parent)
+
+    // Re-hydrate with real children against the now-real DOM range.
+    root.hydrating = true
+    const cursor = new HydrationCursor(parent, state.startMark.nextSibling, state.endMark)
+    setHydrationCursor(fiber, cursor)
+    reconcileChildren(fiber, childrenToArray(state.realChildren), parent, null)
+    clearHydrationCursor(fiber)
+    root.hydrating = false
+    runEffects(root)
+  })
+}
+
+registerTypeMatcher((type) => (type === REACT_SUSPENSE_TYPE ? FiberTag.Suspense : null))
+registerRenderer(FiberTag.Suspense, renderSuspense)
+installCapability('handleSuspended', realHandleSuspended)

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

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

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

@@ -0,0 +1,12 @@
+import { FiberTag } from '../../../core'
+import { REACT_SUSPENSE_TYPE } from '../../../react'
+import { registerTypeMatcher } from '../../reconcile'
+
+// Stub: Suspense feature disabled. `<Suspense>` elements render as Fragments
+// — children mount inline and `fallback` is ignored. Thrown thenables in
+// descendants fall through to the default `handleSuspended` capability
+// (in reconcile.ts), which schedules a re-render when the promise settles.
+// Eventual consistency still works; there's just no fallback UI during the
+// pending window. Boundary-handler stack, streaming hydration integration,
+// and fallback-swap logic are all stripped.
+registerTypeMatcher((type) => (type === REACT_SUSPENSE_TYPE ? FiberTag.Fragment : null))

package/src/dom/index.ts

@@ -0,0 +1,33 @@
+// Side-effect import: registers opt-in features (Portal, etc.) with the
+// reconciler. A vite plugin may alias individual feature modules to their
+// stub variants to strip them from the bundle.
+import './features'
+
+export { flushSync, batchedUpdates as unstable_batchedUpdates } from './root'
+export { createPortal } from './portal'
+
+// Resource hints — stubs
+export function preconnect(_href: string, _opts?: any): void {}
+export function prefetchDNS(_href: string): void {}
+export function preload(_href: string, _opts?: any): void {}
+export function preinit(_href: string, _opts?: any): void {}
+export function preloadModule(_href: string, _opts?: any): void {}
+export function preinitModule(_href: string, _opts?: any): void {}
+
+export const version = '19.2.3'
+
+// Required by React's default export consumers
+import { flushSync, batchedUpdates } from './root'
+import { createPortal } from './portal'
+export default {
+  flushSync,
+  unstable_batchedUpdates: batchedUpdates,
+  createPortal,
+  preconnect,
+  prefetchDNS,
+  preload,
+  preinit,
+  preloadModule,
+  preinitModule,
+  version: '19.2.3',
+}

package/src/dom/portal.ts

@@ -0,0 +1,16 @@
+import type { ReactNode, ReactElement } from '../core'
+import { REACT_PORTAL_TYPE } from '../react'
+
+export function createPortal(
+  children: ReactNode,
+  container: Element,
+  key: string | null = null,
+): ReactElement {
+  return {
+    $$typeof: REACT_PORTAL_TYPE as any,
+    type: REACT_PORTAL_TYPE as any,
+    key: key == null ? null : '' + key,
+    ref: null,
+    props: { children, container },
+  }
+}