@appsent-co/react-native-watchos 0.1.0

package/build/xcframework/Hermes.xcframework/watchos-arm64-simulator/hermes.framework/Headers/Public/RuntimeConfig.h

@@ -0,0 +1,135 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef HERMES_PUBLIC_RUNTIMECONFIG_H
+#define HERMES_PUBLIC_RUNTIMECONFIG_H
+
+#include "hermes/Public/CrashManager.h"
+#include "hermes/Public/CtorConfig.h"
+#include "hermes/Public/GCConfig.h"
+
+#include <cstdint>
+#include <memory>
+
+namespace hermes {
+namespace vm {
+
+enum CompilationMode {
+  SmartCompilation,
+  ForceEagerCompilation,
+  ForceLazyCompilation
+};
+
+enum class SynthTraceMode : int8_t {
+  None,
+  Replaying,
+  Tracing,
+  TracingAndReplaying,
+};
+
+class PinnedHermesValue;
+
+// Parameters for Runtime initialisation.  Check documentation in README.md
+// constexpr indicates that the default value is constexpr.
+#define RUNTIME_FIELDS(F)                                              \
+  /* Parameters to be passed on to the GC. */                          \
+  F(HERMES_NON_CONSTEXPR, vm::GCConfig, GCConfig)                      \
+                                                                       \
+  /* Pre-allocated Register Stack */                                   \
+  F(constexpr, PinnedHermesValue *, RegisterStack, nullptr)            \
+                                                                       \
+  /* Register Stack Size */                                            \
+  F(constexpr, unsigned, MaxNumRegisters, 128 * 1024)                  \
+                                                                       \
+  /* Native stack remaining before assuming overflow */                \
+  F(constexpr, unsigned, NativeStackGap, 64 * 1024)                    \
+                                                                       \
+  /* Whether to allow eval and Function ctor */                        \
+  F(constexpr, bool, EnableEval, true)                                 \
+                                                                       \
+  /* Whether to verify the IR generated by eval and Function ctor */   \
+  F(constexpr, bool, VerifyEvalIR, false)                              \
+                                                                       \
+  /* Whether to optimize the code inside eval and Function ctor */     \
+  F(constexpr, bool, OptimizedEval, false)                             \
+                                                                       \
+  /* Whether to emit async break check instructions in eval code */    \
+  F(constexpr, bool, AsyncBreakCheckInEval, true)                      \
+                                                                       \
+  /* Support for ES6 Promise. */                                       \
+  F(constexpr, bool, ES6Promise, true)                                 \
+                                                                       \
+  /* Support for ES6 Proxy. */                                         \
+  F(constexpr, bool, ES6Proxy, true)                                   \
+                                                                       \
+  /* Support for ES6 Class. */                                         \
+  F(constexpr, bool, ES6Class, false)                                  \
+                                                                       \
+  /* Support for ECMA-402 Intl APIs. */                                \
+  F(constexpr, bool, Intl, true)                                       \
+                                                                       \
+  /* Support for ArrayBuffer, DataView and typed arrays. */            \
+  F(constexpr, bool, ArrayBuffer, true)                                \
+                                                                       \
+  /* Support for using microtasks. */                                  \
+  F(constexpr, bool, MicrotaskQueue, false)                            \
+                                                                       \
+  /* Runtime set up for synth trace. */                                \
+  F(constexpr, SynthTraceMode, SynthTraceMode, SynthTraceMode::None)   \
+                                                                       \
+  /* Enable sampling certain statistics. */                            \
+  F(constexpr, bool, EnableSampledStats, false)                        \
+                                                                       \
+  /* Whether to enable automatic sampling profiler registration */     \
+  F(constexpr, bool, EnableSampleProfiling, false)                     \
+                                                                       \
+  /* Whether to randomize stack placement etc. */                      \
+  F(constexpr, bool, RandomizeMemoryLayout, false)                     \
+                                                                       \
+  /* Eagerly read bytecode into page cache. */                         \
+  F(constexpr, unsigned, BytecodeWarmupPercent, 0)                     \
+                                                                       \
+  /* Signal-based I/O tracking. Slows down execution. If enabled, */   \
+  /* all bytecode buffers > 64 kB passed to Hermes must be mmap:ed. */ \
+  F(constexpr, bool, TrackIO, false)                                   \
+                                                                       \
+  /* Enable contents of HermesInternal */                              \
+  F(constexpr, bool, EnableHermesInternal, true)                       \
+                                                                       \
+  /* Enable methods exposed to JS for testing */                       \
+  F(constexpr, bool, EnableHermesInternalTestMethods, false)           \
+                                                                       \
+  /* Choose lazy/eager compilation mode. */                            \
+  F(constexpr,                                                         \
+    CompilationMode,                                                   \
+    CompilationMode,                                                   \
+    CompilationMode::SmartCompilation)                                 \
+                                                                       \
+  /* Choose whether generators are enabled. */                         \
+  F(constexpr, bool, EnableGenerator, true)                            \
+                                                                       \
+  /* An interface for managing crashes. */                             \
+  F(HERMES_NON_CONSTEXPR,                                              \
+    std::shared_ptr<CrashManager>,                                     \
+    CrashMgr,                                                          \
+    new NopCrashManager)                                               \
+                                                                       \
+  /* The flags passed from a VM experiment */                          \
+  F(constexpr, uint32_t, VMExperimentFlags, 0)                         \
+                                                                       \
+  /* Whether or not block scoping is enabled */                        \
+  F(constexpr, bool, EnableBlockScoping, false)                        \
+  /* RUNTIME_FIELDS END */
+
+_HERMES_CTORCONFIG_STRUCT(RuntimeConfig, RUNTIME_FIELDS, {})
+
+#undef RUNTIME_FIELDS
+
+} // namespace vm
+} // namespace hermes
+
+#endif // HERMES_PUBLIC_RUNTIMECONFIG_H

package/build/xcframework/Hermes.xcframework/watchos-arm64-simulator/hermes.framework/Headers/Public/SamplingProfiler.h

@@ -0,0 +1,273 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef HERMES_PUBLIC_SAMPLINGPROFILER_H
+#define HERMES_PUBLIC_SAMPLINGPROFILER_H
+
+#include <hermes/Public/HermesExport.h>
+
+#include <cstdint>
+#include <deque>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace facebook {
+namespace hermes {
+namespace sampling_profiler {
+
+/// Helper-class that represents a pair of iterators, which form a range to
+/// iterate over.
+template <typename Iterator>
+class Range {
+ public:
+  Range(Iterator begin, Iterator end) : begin_(begin), end_(end) {}
+
+  Iterator begin() const {
+    return begin_;
+  }
+  Iterator end() const {
+    return end_;
+  }
+
+ private:
+  Iterator begin_;
+  Iterator end_;
+};
+
+/// Helper for creating Range and deducing the type based on input.
+template <typename Iterator>
+Range<Iterator> makeRange(Iterator begin, Iterator end) {
+  return Range<Iterator>(begin, end);
+}
+
+/// JavaScript function frame. Guaranteed to have function name, potentially
+/// an empty string, if function is anonymous or if function names were filtered
+/// out during bytecode compilation. Could have scriptId, url, line and column
+/// numbers, if debug source location is available.
+class HERMES_EXPORT ProfileSampleCallStackJSFunctionFrame {
+ public:
+  explicit ProfileSampleCallStackJSFunctionFrame(
+      std::string_view functionName,
+      uint32_t scriptId,
+      const std::optional<std::string_view> &scriptUrl = std::nullopt,
+      const std::optional<uint32_t> &lineNumber = std::nullopt,
+      const std::optional<uint32_t> &columnNumber = std::nullopt)
+      : functionName_(functionName),
+        scriptId_(scriptId),
+        scriptUrl_(scriptUrl),
+        lineNumber_(lineNumber),
+        columnNumber_(columnNumber) {}
+
+  /// \return name of the function that represents call frame.
+  std::string_view getFunctionName() const {
+    return functionName_;
+  }
+
+  /// \return id of the corresponding script in the VM.
+  uint32_t getScriptId() const {
+    return scriptId_;
+  }
+
+  bool hasScriptUrl() const {
+    return scriptUrl_.has_value();
+  }
+
+  /// \return source url of the corresponding script in the VM.
+  std::string_view getScriptUrl() const {
+    return scriptUrl_.value();
+  }
+
+  bool hasFunctionLineNumber() const {
+    return lineNumber_.has_value();
+  }
+
+  /// \return 1-based line number of the location where the function definition
+  /// starts.
+  uint32_t getFunctionLineNumber() const {
+    return lineNumber_.value();
+  }
+
+  bool hasFunctionColumnNumber() const {
+    return columnNumber_.has_value();
+  }
+
+  /// \return 1-based column number of the location where the function
+  /// definition starts.
+  uint32_t getFunctionColumnNumber() const {
+    return columnNumber_.value();
+  }
+
+ private:
+  std::string_view functionName_;
+  uint32_t scriptId_;
+  std::optional<std::string_view> scriptUrl_;
+  std::optional<uint32_t> lineNumber_;
+  std::optional<uint32_t> columnNumber_;
+};
+
+/// Native (Hermes) function frame. Example: implementation of a built-in
+/// Array.prototype.map.
+class HERMES_EXPORT ProfileSampleCallStackNativeFunctionFrame {
+ public:
+  explicit ProfileSampleCallStackNativeFunctionFrame(
+      std::string_view functionName)
+      : functionName_(functionName) {}
+
+  /// \return name of the function that represents call frame.
+  std::string_view getFunctionName() const {
+    return functionName_;
+  }
+
+ private:
+  std::string_view functionName_;
+};
+
+/// Host function frame. Native functions defined by the integrator. Example:
+/// for React Native, this could be performance.measure or console.log.
+class HERMES_EXPORT ProfileSampleCallStackHostFunctionFrame {
+ public:
+  explicit ProfileSampleCallStackHostFunctionFrame(
+      std::string_view functionName)
+      : functionName_(functionName) {}
+
+  /// \return name of the function that represents call frame.
+  std::string_view getFunctionName() const {
+    return functionName_;
+  }
+
+ private:
+  std::string_view functionName_;
+};
+
+/// Frame that suspends the execution of the VM: could be GC, Debugger or
+/// combination of them.
+class HERMES_EXPORT ProfileSampleCallStackSuspendFrame {
+ public:
+  /// Subtype of the Suspend frame.
+  enum class SuspendFrameKind {
+    GC, /// Frame that suspends the execution of the VM due to GC.
+    Debugger, /// Frame that suspends the execution of the VM due to debugger.
+    Multiple, /// Multiple suspensions have occurred.
+  };
+
+  explicit ProfileSampleCallStackSuspendFrame(
+      const SuspendFrameKind suspendFrameKind)
+      : suspendFrameKind_(suspendFrameKind) {}
+
+  /// \return subtype of the suspend frame.
+  SuspendFrameKind getSuspendFrameKind() const {
+    return suspendFrameKind_;
+  }
+
+ private:
+  SuspendFrameKind suspendFrameKind_;
+};
+
+/// Variant of all possible call stack frames options.
+using ProfileSampleCallStackFrame = std::variant<
+    ProfileSampleCallStackSuspendFrame,
+    ProfileSampleCallStackNativeFunctionFrame,
+    ProfileSampleCallStackHostFunctionFrame,
+    ProfileSampleCallStackJSFunctionFrame>;
+
+/// A pair of a timestamp and a snapshot of the call stack at this point in
+/// time.
+class HERMES_EXPORT ProfileSample {
+ public:
+  using CallStackFrameIterator =
+      std::vector<ProfileSampleCallStackFrame>::const_iterator;
+
+  ProfileSample(
+      uint64_t timestamp,
+      uint64_t threadId,
+      std::vector<ProfileSampleCallStackFrame> callStack)
+      : timestamp_(timestamp),
+        threadId_(threadId),
+        callStack_(std::move(callStack)) {}
+
+  /// \return serialized unix timestamp in microseconds granularity. The
+  /// moment when this sample was recorded.
+  uint64_t getTimestamp() const {
+    return timestamp_;
+  }
+
+  /// \return thread id where sample was recorded.
+  uint64_t getThreadId() const {
+    return threadId_;
+  }
+
+  /// \return a pair of iterators that can be used for iterating over call stack
+  /// frames, the order will be from callee to caller.
+  Range<CallStackFrameIterator> getCallStackFramesRange() const {
+    return makeRange(callStack_.begin(), callStack_.end());
+  }
+
+  /// \return the number of frames inside the call stack of this sample.
+  size_t getCallStackFramesCount() const {
+    return callStack_.size();
+  }
+
+ private:
+  /// When the call stack snapshot was taken (μs).
+  uint64_t timestamp_;
+  /// Thread id where sample was recorded.
+  uint64_t threadId_;
+  /// Snapshot of the call stack. The first element of the vector is
+  /// the lowest frame in the stack.
+  std::vector<ProfileSampleCallStackFrame> callStack_;
+};
+
+/// Contains relevant information about the sampled trace from start to finish.
+class HERMES_EXPORT Profile {
+ public:
+  using SampleIterator = std::vector<ProfileSample>::const_iterator;
+
+  Profile(
+      std::vector<ProfileSample> samples,
+      std::unique_ptr<std::deque<std::string>> stringStorage)
+      : samples_(std::move(samples)),
+        stringStorage_(std::move(stringStorage)) {}
+
+  Profile(Profile &&) = default;
+  Profile &operator=(Profile &&) = default;
+
+  /// Not copyable, maintains the ownership of the storage of strings.
+  Profile(const Profile &) = delete;
+  Profile &operator=(const Profile &) = delete;
+
+  ~Profile() = default;
+
+  /// \return a pair of iterators that can be used for iterating over recorded
+  /// samples, will happen in chronological order.
+  Range<SampleIterator> getSamplesRange() const {
+    return makeRange(samples_.begin(), samples_.end());
+  }
+
+  /// \return the number of recorded samples.
+  size_t getSamplesCount() const {
+    return samples_.size();
+  }
+
+ private:
+  /// List of recorded samples, should be chronologically sorted.
+  std::vector<ProfileSample> samples_;
+  /// Smart pointer to the string storage, owns the strings.
+  /// Frames inside this Profile keep a reference to the storage and know how to
+  /// get std::string_view to the actual string.
+  /// The storage lifetime is tied to the lifetime of the Profile. Samples and
+  /// Frames should not outlive the Profile.
+  std::unique_ptr<std::deque<std::string>> stringStorage_;
+};
+
+} // namespace sampling_profiler
+} // namespace hermes
+} // namespace facebook
+
+#endif

package/build/xcframework/Hermes.xcframework/watchos-arm64-simulator/hermes.framework/Headers/RuntimeTaskRunner.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+#ifndef HERMES_RUNTIMETASKRUNNER_H
+#define HERMES_RUNTIMETASKRUNNER_H
+
+#include "AsyncDebuggerAPI.h"
+
+namespace facebook {
+namespace hermes {
+namespace debugger {
+
+using RuntimeTask = std::function<void(HermesRuntime &)>;
+using EnqueueRuntimeTaskFunc = std::function<void(RuntimeTask)>;
+
+enum class TaskQueues {
+  All,
+  Integrator,
+};
+
+/// Helper for users of AsyncDebuggerAPI that makes it easy to find the
+/// earliest opportunity to use the runtime. There are two ways to become
+/// the exclusive user of the runtime:
+/// - Ask the AsyncDebuggerAPI to interrupt execution and provide a reference
+///   to the runtime. Interrupting will only succeed when JavaScript is
+///   running, so this method won't produce a prompt response if JavaScript is
+///   not running.
+/// - Ask the owner of the runtime to provide a reference to the runtime. If
+///   the owner is currently running JavaScript (e.g. via a call to
+///   evaluateJavaScript), this method won't produce a prompt response.
+/// To cover both cases (when JavaScript is running, and when JavaScript isn't
+/// running), this helper requests the runtime from both sources, executes the
+/// task via the first responder, and sets a flag to indicate to the second
+/// responder that nothing more needs to be done.
+class RuntimeTaskRunner
+    : public std::enable_shared_from_this<RuntimeTaskRunner> {
+ public:
+  RuntimeTaskRunner(
+      debugger::AsyncDebuggerAPI &debugger,
+      EnqueueRuntimeTaskFunc enqueueRuntimeTaskFunc);
+  ~RuntimeTaskRunner();
+
+  /// Schedule a task to be run with access to the runtime at the earliest
+  /// opportunity. Before returning, the task is added to the relevant task
+  /// queues managed by the \p AsyncDebuggerAPI and/or the intergator, with no
+  /// lingering references to the \p RuntimeTaskRunner. Thus, tasks can be
+  /// enqueued even if the task runner will be destroyed shortly after.
+  void enqueueTask(RuntimeTask task, TaskQueues queues = TaskQueues::All);
+
+ private:
+  /// API where the runtime can be obtained when JavaScript is running.
+  debugger::AsyncDebuggerAPI &debugger_;
+
+  /// Function provided by the integrator that enqueues a task to be run
+  /// when JavaScript is not running.
+  EnqueueRuntimeTaskFunc enqueueRuntimeTask_;
+};
+
+} // namespace debugger
+} // namespace hermes
+} // namespace facebook
+
+#endif // HERMES_RUNTIMETASKRUNNER_H