wasmer-napi 0.702.0-alpha.3

NAPI library for Wasmer WebAssembly runtime
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
131
132
133
134
135
136
137
138
139
140
141

#ifndef NAPI_QUICKJS_MODULE_WRAP_H_
#define NAPI_QUICKJS_MODULE_WRAP_H_

#include "../../../include/js_native_api.h"

#include <cstddef>
#include <cstdint>
#include <string>
#include <vector>
#include <quickjs.h>

namespace quickjs::detail
{

class napi_module_wrap__
{
public:
  napi_module_wrap__(napi_env env, JSContext *context);
  ~napi_module_wrap__();

  void teardown();

  napi_status create_source_text(napi_value wrapper,
                                 napi_value url,
                                 napi_value context_or_undefined,
                                 napi_value source,
                                 int32_t line_offset,
                                 int32_t column_offset,
                                 napi_value cached_data_or_id,
                                 void **handle_out);
  napi_status create_synthetic(napi_value wrapper,
                               napi_value url,
                               napi_value context_or_undefined,
                               napi_value export_names,
                               napi_value synthetic_eval_steps,
                               void **handle_out);
  napi_status destroy(void *handle);
  napi_status get_module_requests(void *handle, napi_value *result_out);
  napi_status link(void *handle, size_t count, void *const *linked_handles);
  napi_status instantiate(void *handle);
  napi_status evaluate(void *handle,
                       int64_t timeout,
                       bool break_on_sigint,
                       napi_value *result_out);
  napi_status evaluate_sync(void *handle,
                            napi_value filename,
                            napi_value parent_filename,
                            napi_value *result_out);
  napi_status get_namespace(void *handle, napi_value *result_out);
  napi_status get_status(void *handle, int32_t *status_out);
  napi_status get_error(void *handle, napi_value *result_out);
  napi_status has_top_level_await(void *handle, bool *result_out);
  napi_status has_async_graph(void *handle, bool *result_out);
  napi_status check_unsettled_top_level_await(napi_value module_wrap,
                                              bool warnings,
                                              bool *settled_out);
  napi_status set_export(void *handle,
                         napi_value export_name,
                         napi_value export_value);
  napi_status set_module_source_object(void *handle, napi_value source_object);
  napi_status get_module_source_object(void *handle, napi_value *result_out);
  napi_status create_cached_data(void *handle, napi_value *result_out);
  napi_status set_import_module_dynamically_callback(napi_value callback);
  napi_status set_initialize_import_meta_object_callback(napi_value callback);
  napi_status import_module_dynamically(size_t argc,
                                        napi_value const *argv,
                                        napi_value *result_out);
  napi_status create_required_module_facade(void *handle, napi_value *result_out);
  void register_dynamic_import_referrer(napi_value referrer_name,
                                        napi_value host_defined_option_id);
  void unregister_dynamic_import_referrer(napi_value referrer_name,
                                          napi_value host_defined_option_id);

  int initialize_synthetic_module(JSModuleDef *module);
  int initialize_import_meta(JSModuleDef *module, JSValueConst meta);
  JSValue import_module_dynamically(JSModuleDef *referrer,
                                    JSValueConst referrer_name,
                                    JSValueConst specifier,
                                    JSValueConst attributes,
                                    JSModuleImportPhaseEnum phase);

private:
  struct request_record;
  struct record;
  struct script_referrer;

  record *find(void *handle) const;
  record *find_by_module(JSModuleDef *module) const;
  record *find_by_wrapper(JSValueConst wrapper) const;
  void remove(record *entry);
  void free_record(record *entry);

  JSValue get_host_defined_option_symbol() const;
  JSValue get_symbols_binding_property(const char *name) const;
  JSValue get_or_create_host_defined_option(napi_value wrapper,
                                            napi_value candidate,
                                            const char *description) const;
  void set_host_defined_option(napi_value wrapper, JSValueConst value) const;
  JSValue create_frozen_null_proto_object() const;
  JSValue clone_attributes(JSValueConst value) const;
  napi_status throw_error(const char *code, const char *message);
  napi_status return_pending_exception(const char *message);
  napi_status wrap_owned(JSValue value, napi_value *result_out) const;
  JSValue call_callback(JSValueConst callback,
                        int argc,
                        JSValueConst *argv) const;
  napi_status cache_module_requests(record *entry);

  static int synthetic_init(JSContext *ctx, JSModuleDef *module);
  static int host_import_meta_init(JSContext *ctx,
                                   JSModuleDef *module,
                                   JSValueConst meta,
                                   void *opaque);
  static JSValue host_dynamic_import(JSContext *ctx,
                                     JSModuleDef *referrer,
                                     JSValueConst referrer_name,
                                     JSValueConst specifier,
                                     JSValueConst attributes,
                                     JSModuleImportPhaseEnum phase,
                                     void *opaque);

  // Owning environment and QuickJS context.
  napi_env env_;
  JSContext *ctx_;

  // Host module callbacks.
  JSValue import_module_dynamically_callback_;
  JSValue initialize_import_meta_callback_;

  // Module records and referrer metadata.
  std::vector<record *> records_;
  std::vector<script_referrer> script_referrers_;
  uint64_t facade_counter_ = 0;

  // Subsystem lifecycle.
  bool torn_down_ = false;
};

} // namespace quickjs::detail

#endif // NAPI_QUICKJS_MODULE_WRAP_H_