@use-voltra/core 2.0.0 → 2.1.0

package/src/renderer/context-registry.ts

@@ -0,0 +1,40 @@
+import { Context } from 'react'
+
+declare module 'react' {
+  interface Context<T> {
+    _currentValue: T
+  }
+}
+
+export type ContextRegistry = {
+  pushProvider: <T>(context: Context<T>, value: T) => void
+  popProvider: <T>(context: Context<T>) => void
+  readContext: <T>(context: Context<T>) => T
+}
+
+export const getContextRegistry = (): ContextRegistry => {
+  const contextMap = new Map()
+
+  return {
+    pushProvider: <T>(context: Context<T>, value: T) => {
+      const stack = contextMap.get(context) || []
+      stack.push(value)
+      contextMap.set(context, stack)
+    },
+    popProvider: <T>(context: Context<T>) => {
+      const stack = contextMap.get(context)
+      if (stack) {
+        stack.pop()
+      }
+    },
+    readContext: <T>(context: Context<T>) => {
+      const stack = contextMap.get(context)
+
+      if (stack && stack.length > 0) {
+        return stack[stack.length - 1]
+      }
+
+      return context._currentValue
+    },
+  }
+}

package/src/renderer/dispatcher.ts

@@ -0,0 +1,105 @@
+import React, { Context, ReactDispatcher, ReactHooksDispatcher } from 'react'
+
+import { ContextRegistry } from './context-registry.js'
+
+const REACT_CONTEXT_TYPE = Symbol.for('react.context')
+const REACT_MEMO_CACHE_SENTINEL = Symbol.for('react.memo_cache_sentinel')
+
+declare module 'react' {
+  type HookFn = (...args: any[]) => any
+
+  export type ReactHooksDispatcher = {
+    useState: HookFn
+    useReducer: HookFn
+    useEffect: HookFn
+    useLayoutEffect: HookFn
+    useInsertionEffect: HookFn
+    useCallback: HookFn
+    useMemo: HookFn
+    useRef: HookFn
+    useContext: HookFn
+    useId: HookFn
+    useImperativeHandle: HookFn
+    useDebugValue: HookFn
+    useDeferredValue: HookFn
+    useTransition: HookFn
+    useSyncExternalStore: HookFn
+    use: HookFn
+    useActionState: HookFn
+    useOptimistic: HookFn
+    useEffectEvent: HookFn
+    useMemoCache: HookFn
+    useCacheRefresh: HookFn
+  }
+
+  export type ReactDispatcher = {
+    H: ReactHooksDispatcher
+  }
+
+  let __CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE: ReactDispatcher
+}
+
+export const getHooksDispatcher = (registry: ContextRegistry): ReactHooksDispatcher => ({
+  useContext: <T>(context: Context<T>) => registry.readContext(context),
+  use: <T>(usable: React.Usable<T>): T => {
+    if (
+      usable !== null &&
+      typeof usable === 'object' &&
+      (usable as { $$typeof?: symbol }).$$typeof === REACT_CONTEXT_TYPE
+    ) {
+      return registry.readContext(usable as unknown as Context<T>)
+    }
+
+    if (
+      usable !== null &&
+      (typeof usable === 'object' || typeof usable === 'function') &&
+      typeof (usable as { then?: unknown }).then === 'function'
+    ) {
+      throw new Error(
+        'use() with promises is not supported in Voltra. Async data fetching is not available in this synchronous renderer.'
+      )
+    }
+
+    throw new Error(`An unsupported type was passed to use(): ${String(usable)}`)
+  },
+  useState: <S>(initial?: S | (() => S)) => [
+    typeof initial === 'function' ? (initial as () => S)() : initial,
+    () => {},
+  ],
+  useReducer: <S, I, A extends React.AnyActionArg>(
+    _: (prevState: S, ...args: A) => S,
+    initialArg: I,
+    init?: (i: I) => S
+  ): [S, React.ActionDispatch<A>] => {
+    const state = init ? init(initialArg) : initialArg
+    return [state as S, () => {}]
+  },
+  useMemo: (factory) => factory(),
+  useCallback: (cb) => cb,
+  useRef: (initial) => ({ current: initial }),
+  useEffect: () => {},
+  useLayoutEffect: () => {},
+  useInsertionEffect: () => {},
+  useId: () => Math.random().toString(36).substr(2, 9),
+  useDebugValue: () => {},
+  useImperativeHandle: () => {},
+  useDeferredValue: <T>(value: T) => value,
+  useTransition: () => [false, (func: () => void) => func()],
+  useSyncExternalStore: (_, getSnapshot) => getSnapshot(),
+  useActionState: <S>(_: unknown, initialState: S, _permalink?: string) =>
+    [initialState, () => {}, false] as [S, () => void, boolean],
+  useOptimistic: <T>(passthrough: T) => [passthrough, () => {}] as [T, (action: unknown) => void],
+  useEffectEvent: <T extends Function>(callback: T): T => callback,
+  useMemoCache: (size: number) => {
+    const data = new Array<unknown>(size)
+    for (let i = 0; i < size; i++) {
+      data[i] = REACT_MEMO_CACHE_SENTINEL
+    }
+    return data
+  },
+  useCacheRefresh: () => () => {},
+})
+
+export const getReactCurrentDispatcher = (): ReactDispatcher => {
+  return React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE
+}

package/src/renderer/element-registry.ts

@@ -0,0 +1,69 @@
+import { ReactNode } from 'react'
+
+import { VoltraNodeJson } from '../types.js'
+
+export type ElementRegistry = {
+  isRegistered: (element: ReactNode) => number | undefined
+  register: (element: ReactNode, rendered: VoltraNodeJson) => number
+  getElements: () => VoltraNodeJson[]
+}
+
+export const createElementRegistry = (): ElementRegistry => {
+  const elementToIndex = new Map<ReactNode, number>()
+  const elements: VoltraNodeJson[] = []
+
+  return {
+    isRegistered: (element: ReactNode): number | undefined => {
+      return elementToIndex.get(element)
+    },
+    register: (element: ReactNode, rendered: VoltraNodeJson): number => {
+      const index = elements.length
+      elementToIndex.set(element, index)
+      elements.push(rendered)
+      return index
+    },
+    getElements: (): VoltraNodeJson[] => elements,
+  }
+}
+
+export const preScanForDuplicates = (element: ReactNode): Set<ReactNode> => {
+  const seen = new Set<ReactNode>()
+  const duplicates = new Set<ReactNode>()
+
+  const scan = (node: ReactNode): void => {
+    if (node === null || node === undefined || typeof node !== 'object') {
+      return
+    }
+
+    if (Array.isArray(node)) {
+      for (const child of node) {
+        scan(child)
+      }
+      return
+    }
+
+    if (seen.has(node)) {
+      duplicates.add(node)
+    } else {
+      seen.add(node)
+    }
+
+    if ('props' in node) {
+      const props = (node as { props: Record<string, unknown> }).props
+      if (props) {
+        if (props.children !== undefined) {
+          scan(props.children as ReactNode)
+        }
+
+        for (const [key, value] of Object.entries(props)) {
+          if (key !== 'children' && value && typeof value === 'object' && 'type' in value && 'props' in value) {
+            scan(value as ReactNode)
+          }
+        }
+      }
+    }
+  }
+
+  scan(element)
+  return duplicates
+}

package/src/renderer/flatten-styles.ts

@@ -0,0 +1,24 @@
+type StyleProp<T> = T | T[] | null | undefined | false
+
+type FlatStyleProp<T> = T extends (infer U)[] ? FlatStyleProp<U> : T
+
+export const flattenStyle = <T extends StyleProp<unknown>>(style: T | null | undefined): FlatStyleProp<T> | null => {
+  if (!style) {
+    return null
+  }
+
+  if (!Array.isArray(style)) {
+    return style as FlatStyleProp<T>
+  }
+
+  const result: Record<string, unknown> = {}
+  for (let i = 0, styleLength = style.length; i < styleLength; ++i) {
+    const computedStyle = flattenStyle(style[i])
+    if (computedStyle) {
+      for (const key in computedStyle) {
+        result[key] = computedStyle[key]
+      }
+    }
+  }
+  return result as FlatStyleProp<T>
+}

package/src/renderer/index.ts

@@ -0,0 +1,14 @@
+export { type ContextRegistry, getContextRegistry } from './context-registry.js'
+export { getHooksDispatcher, getReactCurrentDispatcher } from './dispatcher.js'
+export { createElementRegistry, type ElementRegistry, preScanForDuplicates } from './element-registry.js'
+export { flattenStyle } from './flatten-styles.js'
+export { getRenderCache, type RenderCache } from './render-cache.js'
+export {
+  type ComponentRegistry,
+  createVoltraRenderer,
+  renderVariantToJson,
+  transformProps,
+  VOLTRA_PAYLOAD_VERSION,
+} from './renderer.js'
+export { createStylesheetRegistry, type StylesheetRegistry } from './stylesheet-registry.js'
+export type { VoltraVariantRenderer } from './types.js'

package/src/renderer/render-cache.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react'
+
+import { VoltraNodeJson } from '../types.js'
+import { VoltraVariantRenderer } from './types.js'
+
+export type RenderCache = {
+  getOrRender: VoltraVariantRenderer
+}
+
+export const getRenderCache = (renderer: VoltraVariantRenderer): RenderCache => {
+  const renderCache = new Map<ReactNode, VoltraNodeJson>()
+
+  return {
+    getOrRender: (node: ReactNode): VoltraNodeJson => {
+      const cached = renderCache.get(node)
+
+      if (cached) {
+        return cached
+      }
+
+      const result = renderer(node)
+      renderCache.set(node, result)
+
+      return result
+    },
+  }
+}