@appsent-co/react-native-watchos 0.1.0

package/build/xcframework/simulator/Headers/react/utils/Telemetry.h

@@ -0,0 +1,113 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <chrono>
+#include <type_traits>
+
+namespace facebook::react {
+
+/*
+ * Represents a monotonic clock suitable for measuring intervals.
+ */
+using TelemetryClock = std::chrono::steady_clock;
+
+/*
+ * Represents a point in time satisfied the requirements of TelemetryClock.
+ */
+using TelemetryTimePoint = TelemetryClock::time_point;
+
+/*
+ * Represents a time interval satisfied the requirements of TelemetryClock.
+ */
+using TelemetryDuration = std::chrono::nanoseconds;
+
+/*
+ * Represents a time point which never happens.
+ */
+static const TelemetryTimePoint kTelemetryUndefinedTimePoint =
+    TelemetryTimePoint::max();
+
+/*
+ * Returns a time point representing the current point in time.
+ */
+static inline TelemetryTimePoint telemetryTimePointNow() {
+  return TelemetryClock::now();
+}
+
+/*
+ * Returns a number of milliseconds that passed from some epoch starting time
+ * point to a given time point. The epoch starting time point is not specified
+ * but stays the same for an application run.
+ */
+static inline int64_t telemetryTimePointToMilliseconds(
+    TelemetryTimePoint timePoint) {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(
+             timePoint - TelemetryTimePoint{})
+      .count();
+}
+
+/*
+ * Returns a number of seconds that passed from "Steady Clock" epoch starting
+ * time point to a given time point.
+ */
+static inline double telemetryTimePointToSteadyClockSeconds(
+    TelemetryTimePoint timePoint) {
+  static_assert(
+      std::is_same<decltype(timePoint), std::chrono::steady_clock::time_point>::
+          value,
+      "`TelemetryClock` must be `std::chrono::steady_clock` to make the "
+      "following implementation work correctly.");
+
+  auto nanoseconds = std::chrono::duration_cast<std::chrono::nanoseconds>(
+                         timePoint.time_since_epoch())
+                         .count();
+  return (double)nanoseconds / 1.0e9;
+}
+
+/*
+ * Converts a time point on one clock to a time point on a different clock.
+ */
+template <
+    typename DestinationTimePointT,
+    typename SourceTimePointT,
+    typename DestnationClockT = typename DestinationTimePointT::clock,
+    typename SourceClockT = typename SourceTimePointT::clock>
+DestinationTimePointT clockCast(SourceTimePointT timePoint) {
+  auto sourseClockNow = SourceClockT::now();
+  auto destinationClockNow = DestnationClockT::now();
+  return std::chrono::time_point_cast<typename DestnationClockT::duration>(
+      timePoint - sourseClockNow + destinationClockNow);
+}
+
+/*
+ * Returns a number of seconds that passed from the UNIX Epoch starting time
+ * point to a given time point.
+ * Also known as POSIX time or UNIX Timestamp.
+ */
+static inline double telemetryTimePointToSecondsSinceEpoch(
+    TelemetryTimePoint timePoint) {
+  auto systemClockTimePoint =
+      clockCast<std::chrono::system_clock::time_point, TelemetryTimePoint>(
+          timePoint);
+  return (double)std::chrono::duration_cast<std::chrono::microseconds>(
+             systemClockTimePoint.time_since_epoch())
+             .count() /
+      1000000.0;
+}
+
+/*
+ * Returns a number of milliseconds that represents the given duration object.
+ */
+static inline int64_t telemetryDurationToMilliseconds(
+    TelemetryDuration duration) {
+  return std::chrono::duration_cast<std::chrono::milliseconds>(duration)
+      .count();
+}
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/TemplateStringLiteral.h

@@ -0,0 +1,35 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <array>
+#include <string_view>
+
+namespace facebook::react {
+
+/**
+ * Helper to allow passing string literals as template parameters.
+ * https://ctrpeach.io/posts/cpp20-string-literal-template-parameters/
+ */
+template <size_t N>
+struct TemplateStringLiteral {
+  /* implicit */ constexpr TemplateStringLiteral(const char (&str)[N]) {
+    std::copy_n(str, N, value.data());
+  }
+
+  constexpr operator std::string_view() const {
+    return {value.begin(), value.end() - 1};
+  }
+
+  // Not private, since structural types required for template parameters cannot
+  // have non-punlic data members.
+  std::array<char, N> value{};
+};
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/fnv1a.h

@@ -0,0 +1,53 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <string_view>
+
+#include <react/utils/toLower.h>
+
+namespace facebook::react {
+
+/**
+ * FNV-1a hash function implementation.
+ * Implemented as described in http://www.isthe.com/chongo/tech/comp/fnv/.
+ *
+ * Please use std::hash if possible. `fnv1a` should only be used in cases
+ * when std::hash does not provide the needed functionality. For example,
+ * constexpr.
+ */
+template <typename CharTransformT = std::identity>
+constexpr uint32_t fnv1a(std::string_view string) noexcept {
+  constexpr uint32_t offset_basis = 2166136261;
+
+  uint32_t hash = offset_basis;
+
+  for (const auto& c : string) {
+    hash ^= static_cast<int8_t>(CharTransformT{}(c));
+    // Using shifts and adds instead of multiplication with a prime number.
+    // This is faster when compiled with optimizations.
+    hash +=
+        (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+  }
+
+  return hash;
+}
+
+constexpr uint32_t fnv1aLowercase(std::string_view string) {
+  struct LowerCaseTransform {
+    constexpr char operator()(char c) const {
+      return toLower(c);
+    }
+  };
+
+  return fnv1a<LowerCaseTransform>(string);
+}
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/hash_combine.h

@@ -0,0 +1,33 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <functional>
+#include <type_traits>
+
+namespace facebook::react {
+
+template <typename T>
+concept Hashable = !std::is_same_v<T, const char*> && (requires(T a) {
+  { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;
+});
+
+template <Hashable T, Hashable... Rest>
+void hash_combine(std::size_t& seed, const T& v, const Rest&... rest) {
+  seed ^= std::hash<T>{}(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
+  (hash_combine(seed, rest), ...);
+}
+
+template <Hashable T, Hashable... Args>
+std::size_t hash_combine(const T& v, const Args&... args) {
+  std::size_t seed = 0;
+  hash_combine<T, Args...>(seed, v, args...);
+  return seed;
+}
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/iequals.h

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <react/utils/toLower.h>
+#include <string_view>
+
+namespace facebook::react {
+
+/**
+ * constexpr check for case insensitive equality of two strings.
+ */
+constexpr bool iequals(std::string_view a, std::string_view b) {
+  if (a.size() != b.size()) {
+    return false;
+  }
+
+  for (size_t i = 0; i < a.size(); i++) {
+    if (toLower(a[i]) != toLower(b[i])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/jsi-utils.h

@@ -0,0 +1,31 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <jsi/jsi.h>
+#include <string>
+
+namespace facebook::react {
+
+/**
+ * Defines a property on the global object that is neither enumerable, nor
+ * configurable, nor writable. This ensures that the private globals exposed by
+ * ReactInstance cannot overwritten by third-party JavaScript code. It also
+ * ensures that third-party JavaScript code unaware of these globals isn't able
+ * to accidentally access them. In JavaScript, equivalent to:
+ *
+ * Object.defineProperty(global, propName, {
+ *   value: value
+ * })
+ */
+void defineReadOnlyGlobal(
+    jsi::Runtime& runtime,
+    const std::string& propName,
+    jsi::Value&& value);
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/platform/android/react/utils/LowPriorityExecutor.h

@@ -0,0 +1,14 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+namespace facebook::react::LowPriorityExecutor {
+
+void execute(std::function<void()>&& workItem);
+
+} // namespace facebook::react::LowPriorityExecutor

package/build/xcframework/simulator/Headers/react/utils/platform/cxx/react/utils/LowPriorityExecutor.h

@@ -0,0 +1,18 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <functional>
+
+namespace facebook::react::LowPriorityExecutor {
+
+inline void execute(std::function<void()>&& workItem) {
+  workItem();
+}
+
+} // namespace facebook::react::LowPriorityExecutor

package/build/xcframework/simulator/Headers/react/utils/platform/ios/react/utils/FollyConvert.h

@@ -0,0 +1,18 @@
+/*
+ * 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.
+ */
+
+#import <Foundation/Foundation.h>
+
+#include <folly/dynamic.h>
+
+namespace facebook::react {
+
+folly::dynamic convertIdToFollyDynamic(id json);
+id convertFollyDynamicToId(const folly::dynamic &dyn);
+NSArray<NSString *> *extractKeysFromFollyDynamic(const folly::dynamic &dyn);
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/platform/ios/react/utils/LowPriorityExecutor.h

@@ -0,0 +1,16 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <functional>
+
+namespace facebook::react::LowPriorityExecutor {
+
+void execute(std::function<void()>&& workItem);
+
+} // namespace facebook::react::LowPriorityExecutor

package/build/xcframework/simulator/Headers/react/utils/toLower.h

@@ -0,0 +1,22 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+namespace facebook::react {
+
+/**
+ * constexpr version of tolower
+ */
+constexpr char toLower(char c) {
+  if (c >= 'A' && c <= 'Z') {
+    return static_cast<char>(c + 32);
+  }
+  return c;
+}
+
+} // namespace facebook::react

package/build/xcframework/simulator/Headers/react/utils/to_underlying.h

@@ -0,0 +1,22 @@
+/*
+ * 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.
+ */
+
+#pragma once
+
+#include <type_traits>
+
+namespace facebook::react {
+
+/**
+ * Polyfill of C++ 23 to_underlying()
+ * https://en.cppreference.com/w/cpp/utility/to_underlying
+ */
+constexpr auto to_underlying(auto e) noexcept {
+  return static_cast<std::underlying_type_t<decltype(e)>>(e);
+}
+
+} // namespace facebook::react

package/cli/init.js

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+// @ts-check
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawn } = require('node:child_process');
+
+const TEMPLATES = path.join(__dirname, '..', 'plugin', 'templates');
+const ENTRY_NAMES = [
+  'index.watchos.tsx',
+  'index.watchos.ts',
+  'index.watchos.jsx',
+  'index.watchos.js',
+];
+
+function help() {
+  console.log('Usage: npx react-native-watchos init');
+  console.log('');
+  console.log('Scaffolds a watchOS target via @bacons/apple-targets and wires');
+  console.log('@appsent-co/react-native-watchos into app.json.');
+}
+
+async function main() {
+  const cmd = process.argv[2];
+  if (cmd === '-h' || cmd === '--help' || cmd === 'help') {
+    help();
+    return;
+  }
+  if (cmd !== 'init') {
+    help();
+    process.exit(1);
+  }
+
+  const cwd = process.cwd();
+  const targetsRoot = path.join(cwd, 'targets');
+  const existing = listWatchTargets(targetsRoot);
+
+  console.log('› Running `npx create-target watch`…');
+  await spawnInherit('npx', ['--yes', 'create-target', 'watch']);
+
+  const after = listWatchTargets(targetsRoot);
+  const created = after.find((d) => !existing.includes(d)) || after[0];
+  if (!created) {
+    console.error(
+      '\nCould not locate the generated watch target under ./targets/.'
+    );
+    console.error('Skipping ContentView.swift and app.json wiring.');
+    process.exit(1);
+  }
+
+  const targetName = path.basename(created);
+  writeContentView(created);
+  writeEntryFile(cwd);
+  patchAppJson(cwd, targetName);
+
+  console.log('');
+  console.log('✓ @appsent-co/react-native-watchos wired up.');
+  console.log(`  • Target:        targets/${targetName}/`);
+  console.log('  • Entry:         index.watchos.tsx');
+  console.log('  • Next:          npx expo prebuild -p ios --clean');
+}
+
+function listWatchTargets(targetsRoot) {
+  if (!fs.existsSync(targetsRoot)) return [];
+  const out = [];
+  for (const name of fs.readdirSync(targetsRoot)) {
+    const dir = path.join(targetsRoot, name);
+    if (!fs.statSync(dir).isDirectory()) continue;
+    if (isWatchTargetConfig(dir)) out.push(dir);
+  }
+  return out;
+}
+
+function isWatchTargetConfig(dir) {
+  for (const f of ['expo-target.config.json', 'expo-target.config.js']) {
+    const p = path.join(dir, f);
+    if (!fs.existsSync(p)) continue;
+    const content = fs.readFileSync(p, 'utf8');
+    if (/['"]?type['"]?\s*:\s*['"]watch['"]/.test(content)) return true;
+  }
+  return false;
+}
+
+function writeContentView(targetDir) {
+  const dest = path.join(targetDir, 'ContentView.swift');
+  const src = path.join(TEMPLATES, 'ContentView.swift');
+  fs.copyFileSync(src, dest);
+  console.log(`› Wrote ${path.relative(process.cwd(), dest)}`);
+}
+
+function writeEntryFile(cwd) {
+  for (const name of ENTRY_NAMES) {
+    if (fs.existsSync(path.join(cwd, name))) {
+      console.log(`› Found existing ${name} — leaving untouched.`);
+      return;
+    }
+  }
+  const dest = path.join(cwd, 'index.watchos.tsx');
+  fs.copyFileSync(path.join(TEMPLATES, 'index.watchos.tsx'), dest);
+  console.log(`› Wrote ${path.relative(cwd, dest)}`);
+}
+
+function patchAppJson(cwd, targetName) {
+  const p = path.join(cwd, 'app.json');
+  if (!fs.existsSync(p)) {
+    console.warn('');
+    console.warn('! app.json not found. If you use app.config.{js,ts}, add:');
+    console.warn(
+      `    ["@appsent-co/react-native-watchos", { "targetName": "${targetName}" }]`
+    );
+    console.warn('  to plugins, after "@bacons/apple-targets".');
+    return;
+  }
+
+  const raw = fs.readFileSync(p, 'utf8');
+  const json = JSON.parse(raw);
+  const expo = (json.expo = json.expo || {});
+  const plugins = (expo.plugins = expo.plugins || []);
+
+  const isEntry = (entry, name) =>
+    Array.isArray(entry) ? entry[0] === name : entry === name;
+
+  if (plugins.some((e) => isEntry(e, '@appsent-co/react-native-watchos'))) {
+    console.log(
+      '› @appsent-co/react-native-watchos plugin already present in app.json.'
+    );
+    return;
+  }
+
+  const entry = ['@appsent-co/react-native-watchos', { targetName }];
+  const baconIdx = plugins.findIndex((e) =>
+    isEntry(e, '@bacons/apple-targets')
+  );
+  if (baconIdx >= 0) plugins.splice(baconIdx + 1, 0, entry);
+  else plugins.push(entry);
+
+  fs.writeFileSync(p, JSON.stringify(json, null, 2) + '\n');
+  console.log(`› Patched ${path.relative(cwd, p)}`);
+}
+
+function spawnInherit(cmd, args) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { stdio: 'inherit' });
+    child.on('error', reject);
+    child.on('exit', (code) =>
+      code === 0
+        ? resolve()
+        : reject(new Error(`${cmd} ${args.join(' ')} exited with ${code}`))
+    );
+  });
+}
+
+main().catch((err) => {
+  console.error(err.message || err);
+  process.exit(1);
+});

package/cocoapods/autolink.rb

@@ -0,0 +1,76 @@
+require 'json'
+require 'open3'
+require 'pathname'
+require 'cocoapods-core'
+
+# `use_watchos_modules!` — autolink third-party RN modules into a watch target.
+#
+# Designed to be called from inside a `target '<watch>' do ... end` block.
+# Mirrors RN's `use_native_modules!` but filters to packages whose podspec
+# declares `:watchos =>` in `s.platforms`. That declaration is the explicit
+# opt-in signal from the package author that the pod is expected to compile
+# against the watchOS SDK.
+#
+# Reuses the same `react-native config` invocation the iOS target uses so
+# we share the dependency graph; the only divergence is the post-filter.
+#
+# Expo bare:                                        Bare RN:
+#   targets/watch/pods.rb                             ios/Podfile
+#   (auto-loaded by apple-targets extension)          (hand-managed)
+#
+# Both call the same method.
+def use_watchos_modules!(opts = {})
+  config_command = opts[:config_command] || [
+    'npx', '--no-install', '@react-native-community/cli', 'config'
+  ]
+
+  # Splat the array straight to Open3 — joining with spaces and going through
+  # the shell would mangle args that contain quoted Node expressions like
+  # `require('expo/bin/autolinking')`.
+  raw, status = Open3.capture2(*config_command)
+  unless status.success? && !raw.strip.empty?
+    Pod::UI.warn "[@appsent-co/react-native-watchos] autolink: `#{config_command.join(' ')}` produced no usable output; skipping"
+    return
+  end
+
+  config = JSON.parse(raw)
+  deps = config['dependencies'] || {}
+
+  deps.each do |name, dep|
+    podspec_path = dep.dig('platforms', 'ios', 'podspecPath')
+    next unless podspec_path.is_a?(String) && File.exist?(podspec_path)
+
+    # Pass through the path as-is from react-native config. Resolving
+    # symlinks here would diverge from the iOS-side autolinker's declaration
+    # of the same pod and CocoaPods would reject it as a duplicate source.
+    # The caller MUST hand us the same `config_command` the iOS Podfile uses
+    # so both invocations return byte-identical paths.
+
+    spec = begin
+      Pod::Specification.from_file(podspec_path)
+    rescue StandardError => e
+      Pod::UI.warn "[@appsent-co/react-native-watchos] autolink: could not load #{name} podspec (#{e.message}); skipping"
+      next
+    end
+
+    # `available_platforms` returns Pod::Platform objects; `name` is the symbol.
+    has_watchos = spec.available_platforms.any? { |p| p.name == :watchos }
+    next unless has_watchos
+
+    # `pod` requires the podspec's own `s.name`, not the npm package name —
+    # they often differ (e.g. `react-native-worklets` → `RNWorklets`).
+    # CocoaPods resolves `:path` by looking for `<spec.name>.podspec` there.
+    #
+    # Path MUST match the form the iOS autolinker used (relative to the
+    # Pods installation root, i.e. `example/ios`). CocoaPods compares the
+    # `:path` strings byte-for-byte when deduping — an absolute path here vs.
+    # a relative path on the iOS side counts as two different sources for
+    # the same pod and aborts the install.
+    pods_root = Pathname.new(Pod::Config.instance.installation_root)
+    relative_dir = Pathname.new(File.dirname(podspec_path))
+                     .relative_path_from(pods_root)
+                     .to_s
+    Pod::UI.puts "[@appsent-co/react-native-watchos] autolinking #{name} as #{spec.name} (watchOS)"
+    pod spec.name, :path => relative_dir
+  end
+end

package/metro-config.d.ts

@@ -0,0 +1,23 @@
+export interface MetroResolverConfig {
+  platforms?: string[];
+  unstable_conditionsByPlatform?: { [platform: string]: string[] };
+  [key: string]: unknown;
+}
+
+export interface MetroConfigLike {
+  resolver?: MetroResolverConfig;
+  [key: string]: unknown;
+}
+
+/**
+ * Mutates and returns the given Metro config so that `watchos` is a known
+ * resolver platform. Once registered, Metro resolves
+ * `foo.watchos.{ts,tsx,js,jsx}` before falling back to `foo.{ts,tsx,js,jsx}`
+ * whenever a bundle is requested with `?platform=watchos`.
+ *
+ * Idempotent: safe to call more than once on the same config.
+ */
+export function withWatchosMetro<T extends MetroConfigLike>(config: T): T;
+
+declare const _default: typeof withWatchosMetro;
+export default _default;

package/metro-config.js

@@ -0,0 +1 @@
+module.exports = require('./plugin/src/withWatchosMetro');