rari 0.13.6

rari: Runtime Accelerated Rendering Infrastructure - A high-performance React Server Components framework powered by Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

/* eslint-disable no-undef, style/object-curly-spacing */
// oxlint-disable typescript/no-base-to-string
(function () {
  const promiseId = '{promise_id}'
  const boundaryId = '{boundary_id}'
  const capturedGeneration = {render_generation}
  const currentGeneration = globalThis['~suspense']?.renderGeneration || 0

  if (capturedGeneration !== currentGeneration) {
    return Promise.resolve({
      success: false,
      boundary_id: boundaryId,
      error: `Stale render generation (expected ${String(capturedGeneration)}, current ${currentGeneration})`,
      errorName: 'StaleRenderError',
      errorStack: 'No stack trace',
      stale: true,
    })
  }

  const safeSerializeError = function (error, phase) {
    return {
      success: false,
      boundary_id: boundaryId,
      errorContext: { phase, promiseId, componentPath: '{component_path}' },
      errorName: error?.name ?? 'UnknownError',
      error: error?.message ?? (error != null ? String(error) : 'Unknown error'),
      errorStack: error?.stack || 'No stack trace available',
    }
  }

  try {
    const pendingPromises = globalThis['~suspense']?.pendingPromises || []
    const pendingInfo = pendingPromises.find(p => p.id === promiseId)

    if (!pendingInfo) {
      return Promise.resolve({
        success: false,
        boundary_id: boundaryId,
        error: `Pending promise info not found: ${promiseId}`,
        errorName: 'PromiseNotFound',
        errorStack: 'No stack trace',
        errorContext: { phase: 'component_type_check', promiseId, componentPath: '{component_path}' },
      })
    }

    let promise
    if (pendingInfo.componentType && typeof pendingInfo.componentType === 'function') {
      try {
        promise = pendingInfo.componentType(pendingInfo.componentProps || {})
      }
      catch (error) {
        return Promise.resolve(safeSerializeError(error, 'component_invocation'))
      }
    }
    else {
      return Promise.resolve({
        success: false,
        boundary_id: boundaryId,
        error: 'Component type is not a function',
        errorName: 'TypeError',
        errorStack: 'No stack trace',
      })
    }

    if (!promise || typeof promise.then !== 'function') {
      return Promise.resolve({
        success: false,
        boundary_id: boundaryId,
        error: 'Component did not return a promise',
        errorName: 'TypeError',
        errorStack: 'No stack trace',
        errorContext: { phase: 'promise_validation', promiseId, componentPath: '{component_path}' },
      })
    }

    return promise.then(async (resolvedElement) => {
      const genAfterResolve = globalThis['~suspense']?.renderGeneration || 0
      if (genAfterResolve > capturedGeneration) {
        return {
          success: false,
          boundary_id: boundaryId,
          error: `Stale render after resolve (captured ${String(capturedGeneration)}, current ${genAfterResolve})`,
          errorName: 'StaleRenderError',
          errorStack: 'No stack trace',
          stale: true,
        }
      }

      if (resolvedElement === undefined || resolvedElement === null) {
        return {
          success: false,
          boundary_id: boundaryId,
          error: 'Promise resolved to null/undefined',
          errorName: 'InvalidPromiseResolution',
          errorStack: 'No stack trace',
        }
      }

      let rscData
      try {
        if (globalThis['~suspense']) {
          globalThis['~suspense'].pendingPromises = []
          globalThis['~suspense'].discoveredBoundaries = []
          globalThis['~suspense'].promises = {}
          globalThis['~suspense'].currentBoundaryId = null
        }

        if (globalThis.renderToRsc)
          rscData = await globalThis.renderToRsc(resolvedElement, globalThis['~clientComponents'] || {}, boundaryId)
        else
          rscData = resolvedElement
      }
      catch (rscError) {
        return safeSerializeError(rscError, 'rsc_conversion')
      }

      return {
        success: true,
        boundary_id: boundaryId,
        content: rscData,
        needsClientComponentProcessing: true,
      }
    }).catch((awaitError) => {
      return safeSerializeError(awaitError, 'promise_resolution')
    })
  }
  catch (error) {
    return Promise.resolve(safeSerializeError(error, 'composition'))
  }
})()