rari 0.12.0

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

(function initializeServerFunctions() {
  if (!globalThis['~serverFunctions'])
    globalThis['~serverFunctions'] = {}
  if (!globalThis['~serverFunctions'].registered)
    globalThis['~serverFunctions'].registered = new Set()
  if (!globalThis['~serverFunctions'].exported)
    globalThis['~serverFunctions'].exported = {}
  if (!globalThis['~serverFunctions'].all)
    globalThis['~serverFunctions'].all = {}

  globalThis.resolveServerFunctionsForComponent = async function (componentId) {
    const currentComponent
      = componentId || globalThis['~render']?.currentComponent

    const serverFunctions = globalThis['~serverFunctions'].exported || {}
    const functionNames = Object.keys(serverFunctions)

    let registeredCount = 0

    for (const functionName of functionNames) {
      const serverFunction = serverFunctions[functionName]
      if (typeof serverFunction === 'function') {
        if (functionName.startsWith('~rari_') || functionName === 'default')
          continue

        globalThis['~serverFunctions'].registered.add(functionName)
        registeredCount++
      }
    }

    return {
      success: true,
      registered: registeredCount,
      component: currentComponent,
      functions: [...globalThis['~serverFunctions'].registered],
    }
  }

  globalThis.executeServerFunction = async function (
    functionName,
    args = [],
    options = {},
  ) {
    const { useCache = true } = options

    if (useCache && globalThis.PromiseManager) {
      const cachedResult = globalThis.PromiseManager.getFunction(
        functionName,
        args,
      )
      if (cachedResult !== undefined)
        return cachedResult
    }

    let serverFunction
    if (globalThis.RscModuleManager?.getFunction)
      serverFunction = globalThis.RscModuleManager.getFunction(functionName)
    else
      serverFunction = globalThis.getServerFunction?.(functionName)

    if (!serverFunction)
      throw new Error(`Server function '${functionName}' not found`)

    const result = await serverFunction(...args)

    if (useCache && globalThis.PromiseManager?.registerFunction)
      globalThis.PromiseManager.registerFunction(functionName, args, result)

    return result
  }

  globalThis.createEnhancedServerFunctionPromise = function (
    functionName,
    args = [],
    options = {},
  ) {
    const { componentId } = options

    if (globalThis.RscModuleManager?.createPromise) {
      const promise = globalThis.RscModuleManager.createPromise(
        functionName,
        args,
      )

      if (componentId)
        promise['~rsc_component_id'] = componentId

      return promise
    }

    return globalThis.executeServerFunction(functionName, args, options)
  }

  globalThis.isServerFunctionRegistered = function (functionName) {
    return globalThis['~serverFunctions'].registered?.has(functionName) || false
  }

  globalThis.clearServerFunctionCache = function (componentId) {
    globalThis['~serverFunctions'].registered.clear()

    if (globalThis.PromiseManager) {
      if (componentId && globalThis.PromiseManager.clear)
        globalThis.PromiseManager.clear(componentId)
      else if (globalThis.PromiseManager.clearAll)
        globalThis.PromiseManager.clearAll()
    }
  }

  globalThis.ServerFunctions = {
    resolve: globalThis.resolveServerFunctionsForComponent,
    execute: globalThis.executeServerFunction,
    createPromise: globalThis.createEnhancedServerFunctionPromise,
    isRegistered: globalThis.isServerFunctionRegistered,
    clear: globalThis.clearServerFunctionCache,
  }

  return {
    initialized: true,
    timestamp: Date.now(),
    extension: 'server_functions',
    registeredCount: globalThis['~serverFunctions'].registered?.size || 0,
  }
})()