@tanstack/redact 0.0.13 → 0.0.15

package/src/core/internal.ts

@@ -16,31 +16,17 @@ export const enum FiberTag {
   Root = 12,
 }
 
-export const enum FiberFlag {
-  None = 0,
-  Placement = 1 << 0,
-  Update = 1 << 1,
-  Deletion = 1 << 2,
-  Ref = 1 << 3,
-  Effect = 1 << 4,
-  LayoutEffect = 1 << 5,
-  ContentReset = 1 << 6,
-  DidCapture = 1 << 7,
-}
-
 export interface Hook {
-  state: any
-  queue: any
-  deps: any
-  cleanup: any
-  next: Hook | null
+  s: any
+  q: any
+  d: any
+  c: any
+  n: Hook | null
 }
 
 export interface Effect {
-  tag: 'effect' | 'layout' | 'insertion'
-  create: () => any
-  destroy: (() => void) | void
-  deps: ReadonlyArray<unknown> | undefined
+  t: 0 | 1
+  c: () => any
 }
 
 export interface Fiber {
@@ -48,34 +34,31 @@ export interface Fiber {
   type: any
   key: string | null
   ref: Ref<any> | null
-  pendingProps: any
-  memoizedProps: any
-  memoizedState: any
-  stateNode: any
+  pp: any
+  mp: any
+  ms: any
+  sn: any
   dom: Node | null
   parent: Fiber | null
   child: Fiber | null
   sibling: Fiber | null
   hooks: Hook | null
-  effects: Effect[] | null
-  layoutEffects: Effect[] | null
-  cleanups: Array<() => void> | null
-  flags: FiberFlag
-  dirty: boolean
-  unmounted: boolean
+  cu: Array<() => void> | null
+  dy: boolean
+  um: boolean
   root: FiberRoot | null
 }
 
 export interface FiberRoot {
-  container: Element | DocumentFragment
-  current: Fiber
-  pending: Set<Fiber>
-  scheduled: boolean
-  onRecoverableError?: ((err: unknown) => void) | undefined
-  onCaughtError?: ((err: unknown) => void) | undefined
-  onUncaughtError?: ((err: unknown) => void) | undefined
-  identifierPrefix: string
-  hydrating: boolean
+  c: Element | DocumentFragment
+  r: Fiber
+  p: Set<Fiber>
+  s: boolean
+  re?: ((err: unknown) => void) | undefined
+  ce?: ((err: unknown) => void) | undefined
+  ue?: ((err: unknown) => void) | undefined
+  i: string
+  h: boolean
 }
 
 export function createFiber(tag: FiberTag, type: any, key: string | null): Fiber {
@@ -84,21 +67,18 @@ export function createFiber(tag: FiberTag, type: any, key: string | null): Fiber
     type,
     key,
     ref: null,
-    pendingProps: null,
-    memoizedProps: null,
-    memoizedState: null,
-    stateNode: null,
+    pp: null,
+    mp: null,
+    ms: null,
+    sn: null,
     dom: null,
     parent: null,
     child: null,
     sibling: null,
     hooks: null,
-    effects: null,
-    layoutEffects: null,
-    cleanups: null,
-    flags: FiberFlag.None,
-    dirty: false,
-    unmounted: false,
+    cu: null,
+    dy: false,
+    um: false,
     root: null,
   }
 }

package/src/dom/dispatcher.ts

@@ -3,37 +3,42 @@ import { ReactSharedInternals, REACT_CONTEXT_TYPE } from '../react'
 import { scheduleUpdate, enqueueEffect, readContext } from './reconcile'
 
 function getCurrentFiber(): Fiber {
-  const f = ReactSharedInternals.currentFiber
-  if (!f) throw new Error('Hook called outside a function component render.')
+  const f = ReactSharedInternals.F
+  if (!f) {
+    if (process.env.NODE_ENV !== 'production') {
+      throw new Error('Hook called outside a function component render.')
+    }
+    throw new Error()
+  }
   return f
 }
 
 function nextHook(): Hook {
   const fiber = getCurrentFiber()
-  const idx = ReactSharedInternals.hookIndex++
+  const idx = ReactSharedInternals.I++
 
-  let prev = ReactSharedInternals.currentHook
+  let prev = ReactSharedInternals.K
 
   if (idx === 0) {
     if (fiber.hooks) {
-      ReactSharedInternals.currentHook = fiber.hooks
+      ReactSharedInternals.K = fiber.hooks
       return fiber.hooks
     }
-    const h: Hook = { state: undefined, queue: undefined, deps: undefined, cleanup: undefined, next: null }
+    const h: Hook = { s: undefined, q: undefined, d: undefined, c: undefined, n: null }
     fiber.hooks = h
-    ReactSharedInternals.currentHook = h
+    ReactSharedInternals.K = h
     return h
   }
 
-  if (prev && prev.next) {
-    ReactSharedInternals.currentHook = prev.next
-    return prev.next
+  if (prev && prev.n) {
+    ReactSharedInternals.K = prev.n
+    return prev.n
   }
 
-  const h: Hook = { state: undefined, queue: undefined, deps: undefined, cleanup: undefined, next: null }
-  if (prev) prev.next = h
+  const h: Hook = { s: undefined, q: undefined, d: undefined, c: undefined, n: null }
+  if (prev) prev.n = h
   else fiber.hooks = h
-  ReactSharedInternals.currentHook = h
+  ReactSharedInternals.K = h
   return h
 }
 
@@ -50,6 +55,8 @@ function depsEqual(
   return true
 }
 
+type BasicStateAction<S> = S | ((p: S) => S)
+
 // Singleton — every method reads render context via ReactSharedInternals,
 // and per-hook closures live on the hook itself, so nothing is render-local
 // to capture. Allocating a fresh wrapper + 17 method closures per function-
@@ -62,67 +69,65 @@ export function makeDispatcher() {
 
 function makeDispatcherImpl() {
   return {
-    useState<S>(initial: S | (() => S)) {
-      return this.useReducer<S, S | ((p: S) => S)>(
-        basicReducer as any,
-        typeof initial === 'function' ? (initial as () => S)() : initial,
+    useState<S>(initial: S | (() => S)): [S, (a: BasicStateAction<S>) => void] {
+      return this.useReducer(
+        basicReducer as (state: S, action: BasicStateAction<S>) => S,
+        typeof initial == 'function' ? (initial as () => S)() : initial,
       )
     },
 
     useReducer<S, A>(reducer: (s: S, a: A) => S, initialArg: any, init?: (a: any) => S) {
       const hook = nextHook()
       const fiber = getCurrentFiber()
-      if (hook.queue === undefined) {
-        hook.state = init ? init(initialArg) : initialArg
-        const queue: any = { reducer }
+      if (hook.q === undefined) {
+        hook.s = init ? init(initialArg) : initialArg
+        const queue: any = { r: reducer }
         const dispatch = (action: A) => {
-          const currentState = hook.state as S
-          const next = queue.reducer(currentState, action)
+          const currentState = hook.s as S
+          const next = queue.r(currentState, action)
           if (!Object.is(next, currentState)) {
-            hook.state = next
+            hook.s = next
             scheduleUpdate(fiber)
           }
         }
-        queue.dispatch = dispatch
-        hook.queue = queue
+        queue.d = dispatch
+        hook.q = queue
       } else {
-        hook.queue.reducer = reducer
+        hook.q.r = reducer
       }
-      return [hook.state, hook.queue.dispatch] as [S, (a: A) => void]
+      return [hook.s, hook.q.d] as [S, (a: A) => void]
     },
 
     useEffect(create: () => any, deps?: ReadonlyArray<unknown>) {
       const hook = nextHook()
       const fiber = getCurrentFiber()
-      const prevDeps = hook.deps
+      const prevDeps = hook.d
       if (prevDeps !== undefined && depsEqual(prevDeps, deps)) return
-      hook.deps = deps
+      hook.d = deps
       const effect: Effect = {
-        tag: 'effect',
-        create: () => {
+        t: 0,
+        c: () => {
           // Run the prior cleanup INSIDE the effect run, not during the
           // dispatch/render phase. If render A → B → C all happen back-to-
           // back before the passive microtask drains, dispatch-time cleanup
-          // only fires once (between A→B) and effects B + C both run fresh,
-          // leaving two side-effects (e.g. two plot SVGs) in the DOM. Doing
+          // only fires once (between A→B) and fx B + C both run fresh,
+          // leaving two side-fx (e.g. two plot SVGs) in the DOM. Doing
           // it here, at effect-run time, means every new create first tears
           // down whatever cleanup is currently live on the hook.
-          if (hook.cleanup) {
-            try { hook.cleanup() } catch {}
-            // The prior cleanup was also pushed onto fiber.cleanups; remove
+          if (hook.c) {
+            try { hook.c() } catch {}
+            // The prior cleanup was also pushed onto fiber.cu; remove
             // it so unmount doesn't double-call it.
-            if (fiber.cleanups) {
-              const i = fiber.cleanups.indexOf(hook.cleanup)
-              if (i >= 0) fiber.cleanups.splice(i, 1)
+            if (fiber.cu) {
+              const i = fiber.cu.indexOf(hook.c)
+              if (i >= 0) fiber.cu.splice(i, 1)
             }
-            hook.cleanup = null
+            hook.c = null
           }
           const c = create()
-          hook.cleanup = typeof c === 'function' ? c : null
-          return hook.cleanup
+          hook.c = typeof c == 'function' ? c : null
+          return hook.c
         },
-        destroy: undefined,
-        deps,
       }
       enqueueEffect(fiber, effect)
     },
@@ -130,28 +135,26 @@ function makeDispatcherImpl() {
     useLayoutEffect(create: () => any, deps?: ReadonlyArray<unknown>) {
       const hook = nextHook()
       const fiber = getCurrentFiber()
-      const prevDeps = hook.deps
+      const prevDeps = hook.d
       if (prevDeps !== undefined && depsEqual(prevDeps, deps)) return
-      hook.deps = deps
+      hook.d = deps
       const effect: Effect = {
-        tag: 'layout',
-        create: () => {
+        t: 1,
+        c: () => {
           // Mirror useEffect: tear down the prior cleanup at run time so
-          // coalesced renders don't leak side-effects.
-          if (hook.cleanup) {
-            try { hook.cleanup() } catch {}
-            if (fiber.cleanups) {
-              const i = fiber.cleanups.indexOf(hook.cleanup)
-              if (i >= 0) fiber.cleanups.splice(i, 1)
+          // coalesced renders don't leak side-fx.
+          if (hook.c) {
+            try { hook.c() } catch {}
+            if (fiber.cu) {
+              const i = fiber.cu.indexOf(hook.c)
+              if (i >= 0) fiber.cu.splice(i, 1)
             }
-            hook.cleanup = null
+            hook.c = null
           }
           const c = create()
-          hook.cleanup = typeof c === 'function' ? c : null
-          return hook.cleanup
+          hook.c = typeof c == 'function' ? c : null
+          return hook.c
         },
-        destroy: undefined,
-        deps,
       }
       enqueueEffect(fiber, effect)
     },
@@ -162,18 +165,18 @@ function makeDispatcherImpl() {
 
     useRef<T>(initial: T) {
       const hook = nextHook()
-      if (hook.state === undefined) hook.state = { current: initial }
-      return hook.state as { current: T }
+      if (hook.s === undefined) hook.s = { current: initial }
+      return hook.s as { current: T }
     },
 
     useMemo<T>(factory: () => T, deps?: ReadonlyArray<unknown>) {
       const hook = nextHook()
-      if (hook.deps !== undefined && depsEqual(hook.deps, deps)) {
-        return hook.state as T
+      if (hook.d !== undefined && depsEqual(hook.d, deps)) {
+        return hook.s as T
       }
       const value = factory()
-      hook.state = value
-      hook.deps = deps
+      hook.s = value
+      hook.d = deps
       return value
     },
 
@@ -188,11 +191,11 @@ function makeDispatcherImpl() {
 
     useImperativeHandle<T>(ref: any, factory: () => T, deps?: ReadonlyArray<unknown>) {
       const hook = nextHook()
-      if (hook.deps !== undefined && depsEqual(hook.deps, deps)) return
-      hook.deps = deps
+      if (hook.d !== undefined && depsEqual(hook.d, deps)) return
+      hook.d = deps
       const value = factory()
       if (ref) {
-        if (typeof ref === 'function') ref(value)
+        if (typeof ref == 'function') ref(value)
         else ref.current = value
       }
     },
@@ -203,12 +206,12 @@ function makeDispatcherImpl() {
 
     useId(): string {
       const hook = nextHook()
-      if (hook.state === undefined) {
+      if (hook.s === undefined) {
         const fiber = getCurrentFiber()
         const root = findRootFromFiber(fiber)
-        hook.state = (root?.identifierPrefix ?? ':r') + (idCounter++).toString(36)
+        hook.s = (root?.i ?? ':r') + (idCounter++).toString(36)
       }
-      return hook.state as string
+      return hook.s as string
     },
 
     useTransition(): [boolean, (fn: () => void) => void] {
@@ -227,15 +230,15 @@ function makeDispatcherImpl() {
       const fiber = getCurrentFiber()
       const hook = nextHook()
       const store: {
-        getSnapshot: () => T
-        getServerSnapshot: (() => T) | undefined
-      } = hook.queue ?? {
-        getSnapshot,
-        getServerSnapshot,
+        g: () => T
+        s: (() => T) | undefined
+      } = hook.q ?? {
+        g: getSnapshot,
+        s: getServerSnapshot,
       }
-      hook.queue = store
-      store.getSnapshot = getSnapshot
-      store.getServerSnapshot = getServerSnapshot
+      hook.q = store
+      store.g = getSnapshot
+      store.s = getServerSnapshot
 
       // During hydration, use the server snapshot (if provided) so the tree
       // matches the SSR output. Components like TanStack Router's ClientOnly
@@ -243,54 +246,52 @@ function makeDispatcherImpl() {
       // if we return `true` during hydration, client and server diverge and
       // the tree mounts fresh next to the SSR fallback DOM.
       const root = fiber.root ?? findRootFromFiber(fiber)
-      const isHydrating = Boolean(root?.hydrating)
+      const isHydrating = Boolean(root?.h)
       const value =
         isHydrating && getServerSnapshot ? getServerSnapshot() : getSnapshot()
-      hook.state = value
+      hook.s = value
 
       const deps = [subscribe]
-      if (hook.deps === undefined || !depsEqual(hook.deps, deps)) {
-        hook.deps = deps
+      if (hook.d === undefined || !depsEqual(hook.d, deps)) {
+        hook.d = deps
         const effect: Effect = {
-          tag: 'layout',
-          deps,
-          destroy: undefined,
-          create: () => {
-            if (hook.cleanup) {
+          t: 1,
+          c: () => {
+            if (hook.c) {
               try {
-                hook.cleanup()
+                hook.c()
               } catch {
                 // ignore cleanup failures
               }
-              if (fiber.cleanups) {
-                const i = fiber.cleanups.indexOf(hook.cleanup)
-                if (i >= 0) fiber.cleanups.splice(i, 1)
+              if (fiber.cu) {
+                const i = fiber.cu.indexOf(hook.c)
+                if (i >= 0) fiber.cu.splice(i, 1)
               }
-              hook.cleanup = null
+              hook.c = null
             }
 
             let unsubscribed = false
             const cleanup = () => {
               unsubscribed = true
-              if (typeof unsubscribe === 'function') {
+              if (typeof unsubscribe == 'function') {
                 unsubscribe()
               }
             }
             const forceUpdate = () => {
-              if (unsubscribed || fiber.unmounted) {
+              if (unsubscribed || fiber.um) {
                 return
               }
 
               let next: T
               try {
-                next = store.getSnapshot()
+                next = store.g()
               } catch {
                 scheduleUpdate(fiber)
                 return
               }
 
-              if (!Object.is(hook.state, next)) {
-                hook.state = next
+              if (!Object.is(hook.s, next)) {
+                hook.s = next
                 scheduleUpdate(fiber)
               }
             }
@@ -299,12 +300,12 @@ function makeDispatcherImpl() {
             // If we served the server snapshot, run a post-hydration check so
             // components like `useHydrated()` flip from false → true after the
             // initial render commits. Queued late so hydration finishes first.
-            if (isHydrating && store.getServerSnapshot) {
+            if (isHydrating && store.s) {
               queueMicrotask(() => queueMicrotask(forceUpdate))
             }
 
             forceUpdate()
-            hook.cleanup = cleanup
+            hook.c = cleanup
             return cleanup
           },
         }
@@ -314,11 +315,16 @@ function makeDispatcherImpl() {
     },
 
     use<T>(resource: any): T {
-      if (resource == null) throw new Error('use() received null or undefined')
+      if (resource == null) {
+        if (process.env.NODE_ENV !== 'production') {
+          throw new Error('use() received null or undefined')
+        }
+        throw new Error()
+      }
       if (resource.$$typeof === REACT_CONTEXT_TYPE) {
         return readContext(getCurrentFiber(), resource)
       }
-      if (typeof resource.then === 'function') {
+      if (typeof resource.then == 'function') {
         const thenable = resource
         switch (thenable.status) {
           case 'fulfilled':
@@ -347,13 +353,16 @@ function makeDispatcherImpl() {
           }
         }
       }
-      throw new Error('use() expected a Promise or Context')
+      if (process.env.NODE_ENV !== 'production') {
+        throw new Error('use() expected a Promise or Context')
+      }
+      throw new Error()
     },
   }
 }
 
-function basicReducer<S>(state: S, action: S | ((p: S) => S)): S {
-  return typeof action === 'function' ? (action as (p: S) => S)(state) : action
+function basicReducer<S>(state: S, action: BasicStateAction<S>): S {
+  return typeof action == 'function' ? (action as (p: S) => S)(state) : action
 }
 
 let idCounter = 0

package/src/dom/dom.ts

@@ -240,7 +240,7 @@ function setEventHandler(el: Element, name: string, next: any, prev: any): void
   // legacy `onclick="..."` HTML attribute (string handler) is a known XSS
   // vector if a parent spreads untrusted props onto a host element. React
   // also ignores non-function handlers.
-  if (next != null && typeof next !== 'function') next = null
+  if (next != null && typeof next != 'function') next = null
 
   const capture = name.endsWith('Capture')
   const reactEventName = name.slice(2, capture ? -7 : undefined)

package/src/dom/event-replay.ts

@@ -13,43 +13,27 @@
 export function drainReplayQueue(): void {
   const g = globalThis as any
   const q = g.$RE_q as Array<[string, EventTarget, number]> | undefined
-  if (!q) return
 
+  if (!q) return
   // Stop capturing before replaying so we don't re-capture what we dispatch.
-  if (typeof g.$RE_stop === 'function') {
-    try {
-      g.$RE_stop()
-    } catch {}
-  }
+  try {
+    g.$RE_stop?.()
+  } catch {}
 
-  const events = q.splice(0)
-  for (const [type, target] of events) {
+  for (const [type, target] of q.splice(0)) {
     try {
-      const ev = createEvent(type)
-      target.dispatchEvent(ev)
+      target.dispatchEvent(createEvent(type))
     } catch {}
   }
 }
 
 function createEvent(type: string): Event {
-  switch (type) {
-    case 'click':
-    case 'dblclick':
-    case 'mousedown':
-    case 'mouseup':
-    case 'contextmenu':
-      return new MouseEvent(type, { bubbles: true, cancelable: true })
-    case 'keydown':
-    case 'keyup':
-    case 'keypress':
-      return new KeyboardEvent(type, { bubbles: true, cancelable: true })
-    case 'input':
-      return new InputEvent(type, { bubbles: true, cancelable: true })
-    case 'submit':
-    case 'change':
-    case 'focus':
-    case 'blur':
-    default:
-      return new Event(type, { bubbles: true, cancelable: true })
-  }
+  const options = { bubbles: true, cancelable: true }
+  return type === 'click'
+    ? new MouseEvent(type, options)
+    : type === 'keydown'
+      ? new KeyboardEvent(type, options)
+      : type === 'input'
+        ? new InputEvent(type, options)
+        : new Event(type, options)
 }

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

@@ -12,8 +12,8 @@ import {
 
 function renderClass(fiber: Fiber, domParent: Node, anchor: Node | null): void {
   const Ctor = fiber.type as any
-  let instance = fiber.stateNode
-  const props = fiber.pendingProps ?? {}
+  let instance = fiber.sn
+  const props = fiber.pp ?? {}
   const isNew = !instance
 
   // Class contextType: read the current value of the subscribed context so
@@ -26,22 +26,22 @@ function renderClass(fiber: Fiber, domParent: Node, anchor: Node | null): void {
     instance.context = ctxValue
     instance._fiber = fiber
     instance._enqueueUpdate = (updater: any, cb?: () => void) => {
-      const next = typeof updater === 'function' ? updater(instance.state, instance.props) : updater
+      const next = typeof updater == 'function' ? updater(instance.state, instance.props) : updater
       if (next != null) instance.state = { ...instance.state, ...next }
       if (cb) {
-        fiber.cleanups ||= []
-        fiber.cleanups.push(cb)
+        fiber.cu ||= []
+        fiber.cu.push(cb)
       }
       scheduleUpdate(fiber)
     }
     instance._forceUpdate = (cb?: () => void) => {
       if (cb) {
-        fiber.cleanups ||= []
-        fiber.cleanups.push(cb)
+        fiber.cu ||= []
+        fiber.cu.push(cb)
       }
       scheduleUpdate(fiber)
     }
-    fiber.stateNode = instance
+    fiber.sn = instance
     if (Ctor.getDerivedStateFromProps) {
       const d = Ctor.getDerivedStateFromProps(props, instance.state)
       if (d) instance.state = { ...instance.state, ...d }
@@ -58,10 +58,10 @@ function renderClass(fiber: Fiber, domParent: Node, anchor: Node | null): void {
     if (instance.shouldComponentUpdate) {
       if (!instance.shouldComponentUpdate(props, instance.state, instance.context)) {
         instance.props = props
-        fiber.memoizedProps = props
+        fiber.mp = props
         // Still need to render children with previous output
-        if (fiber.memoizedState?.rendered) {
-          reconcileChildren(fiber, childrenToArray(fiber.memoizedState.rendered), domParent, anchor)
+        if (fiber.ms?.r) {
+          reconcileChildren(fiber, childrenToArray(fiber.ms.r), domParent, anchor)
         }
         return
       }
@@ -70,7 +70,7 @@ function renderClass(fiber: Fiber, domParent: Node, anchor: Node | null): void {
     // 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.memoizedState = { ...(fiber.memoizedState ?? {}), prevProps, prevState }
+    fiber.ms = { ...(fiber.ms ?? {}), p: prevProps, s: prevState }
   }
 
   let rendered: ReactNode
@@ -85,10 +85,10 @@ function renderClass(fiber: Fiber, domParent: Node, anchor: Node | null): void {
       return
     }
   }
-  fiber.memoizedState = { ...(fiber.memoizedState ?? {}), rendered }
+  fiber.ms = { ...(fiber.ms ?? {}), r: rendered }
 
   reconcileChildren(fiber, childrenToArray(rendered), domParent, anchor)
-  fiber.memoizedProps = props
+  fiber.mp = props
 
   // Schedule lifecycle
   if (isNew) {
@@ -96,8 +96,8 @@ function renderClass(fiber: Fiber, domParent: Node, anchor: Node | null): void {
       scheduleLifecycle(fiber, () => instance.componentDidMount())
     }
   } else if (instance.componentDidUpdate) {
-    const { prevProps, prevState } = fiber.memoizedState ?? {}
-    scheduleLifecycle(fiber, () => instance.componentDidUpdate(prevProps, prevState))
+    const { p, s } = fiber.ms ?? {}
+    scheduleLifecycle(fiber, () => instance.componentDidUpdate(p, s))
   }
 }