one 2.10.0 → 2.11.0

package/macos/host/swift/OneMacToggle.swift

@@ -0,0 +1,71 @@
+import AppKit
+import SwiftUI
+
+// The SwiftUI side of the OneMacToggle Fabric component. The core library finds
+// this class by name, so it lives in the app target and the library carries no
+// Swift. The controlled round trip is OneNativeControlled, the same struct iOS
+// uses (packages/one/ios/OneNativeControlled.swift, compiled into this target).
+final class OneMacToggleModel: ObservableObject {
+  @Published var label = ""
+  @Published var isOn = false
+  var onChange: ((Bool) -> Void)?
+}
+
+private struct OneMacToggleView: View {
+  @ObservedObject var model: OneMacToggleModel
+
+  var body: some View {
+    Toggle(
+      model.label,
+      isOn: Binding(
+        get: { model.isOn },
+        set: { value in
+          model.isOn = value
+          model.onChange?(value)
+        }
+      )
+    )
+    .toggleStyle(.switch)
+    .frame(maxWidth: .infinity, maxHeight: .infinity, alignment: .leading)
+  }
+}
+
+@objc(OneMacToggleHostView)
+final class OneMacToggleHostView: NSView, OneMacosToggleHosting {
+  private let model = OneMacToggleModel()
+  private let hosting: NSHostingView<OneMacToggleView>
+
+  private var controlled = OneNativeControlled(false)
+
+  @objc var label: String {
+    get { model.label }
+    set { model.label = newValue }
+  }
+
+  // native applies a user toggle at once and reports it with the event count;
+  // props win again only once React acknowledges the latest event
+  @objc var onChange: ((Bool, Int, Int) -> Void)?
+
+  @objc(applyValue:acknowledged:revision:)
+  func applyValue(_ isOn: Bool, acknowledged: Int, revision: Int) {
+    guard let next = controlled.applying(isOn, acknowledged: acknowledged, revision: revision) else { return }
+    controlled = next
+    model.isOn = next.value
+  }
+
+  override init(frame frameRect: NSRect) {
+    hosting = NSHostingView(rootView: OneMacToggleView(model: model))
+    super.init(frame: frameRect)
+    model.onChange = { [weak self] value in
+      guard let self, self.controlled.change(value) else { return }
+      self.onChange?(value, self.controlled.eventCount, self.controlled.revision)
+    }
+    hosting.frame = bounds
+    hosting.autoresizingMask = [.width, .height]
+    addSubview(hosting)
+  }
+
+  required init?(coder: NSCoder) {
+    fatalError("init(coder:) is not supported")
+  }
+}

package/macos/react-native/Libraries/Utilities/Platform.js

@@ -0,0 +1,22 @@
+import PlatformIOS from 'react-native/Libraries/Utilities/Platform.ios.js'
+
+// react-native's own Platform.ios.js reports OS 'ios'. On macOS the file
+// resolution still uses that implementation, and this object is the owned
+// override so Platform.OS is 'macos'. Getters stay on the ios object so
+// constants are read when the native module is ready, not at import.
+const Platform = Object.create(PlatformIOS, {
+  OS: { value: 'macos', enumerable: true },
+  select: {
+    value(spec) {
+      if (spec != null && Object.prototype.hasOwnProperty.call(spec, 'macos')) {
+        return spec.macos
+      }
+      if (spec != null && Object.prototype.hasOwnProperty.call(spec, 'native')) {
+        return spec.native
+      }
+      return spec == null ? undefined : spec.default
+    },
+  },
+})
+
+export default Platform

package/macos/template/macos/OneApp/Info.plist

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>en</string>
+  <key>CFBundleExecutable</key>
+  <string>$(EXECUTABLE_NAME)</string>
+  <key>CFBundleIdentifier</key>
+  <string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+  <key>CFBundleName</key>
+  <string>$(PRODUCT_NAME)</string>
+  <key>CFBundlePackageType</key>
+  <string>APPL</string>
+  <key>CFBundleShortVersionString</key>
+  <string>1.0</string>
+  <key>CFBundleVersion</key>
+  <string>1</string>
+  <key>LSMinimumSystemVersion</key>
+  <string>$(MACOSX_DEPLOYMENT_TARGET)</string>
+  <key>NSPrincipalClass</key>
+  <string>NSApplication</string>
+  <key>OneDevServerURL</key>
+  <string>http://localhost:8081</string>
+  <key>NSAppTransportSecurity</key>
+  <dict>
+    <key>NSAllowsLocalNetworking</key>
+    <true/>
+  </dict>
+</dict>
+</plist>

package/macos/template/macos/OneApp/OneApp-Bridging-Header.h

@@ -0,0 +1,3 @@
+#import "OneMacosRootView.h"
+#import "OneMacosToggleHosting.h"
+#import "OneMacosControlsHosting.h"

package/macos/template/macos/OneApp/OneApp.swift

@@ -0,0 +1,20 @@
+import AppKit
+import SwiftUI
+
+private struct OneRootView: NSViewRepresentable {
+  func makeNSView(context: Context) -> OneMacosRootView {
+    OneMacosRootView(bundleURL: OneMacosRootView.defaultBundleURL(), moduleName: "main")
+  }
+
+  func updateNSView(_ nsView: OneMacosRootView, context: Context) {}
+}
+
+@main
+struct OneApp: App {
+  var body: some Scene {
+    WindowGroup {
+      OneRootView()
+        .frame(minWidth: 480, minHeight: 320)
+    }
+  }
+}

package/macos/template/macos/scripts/build-core.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Builds libOneMacosCore.a (React Native's C++ core plus the One host) for the
+# installed react-native. Runs as an Xcode pre build phase and by hand.
+#   RN_ROOT      node_modules/react-native
+#   ONE_MACOS    packages/one/macos
+#   CORE_OUT     build directory, holds libOneMacosCore.a and the deps
+set -euo pipefail
+
+: "${RN_ROOT:?}" "${ONE_MACOS:?}" "${CORE_OUT:?}"
+config="${CORE_CONFIG:-Debug}"
+deps="$CORE_OUT/deps"
+
+nitro_root="$(dirname "$RN_ROOT")/react-native-nitro-modules"
+
+lower="$(echo "$config" | tr '[:upper:]' '[:lower:]')"
+RN_ROOT="$RN_ROOT" "$(dirname "$0")/prepare-deps.sh" "$deps" "$lower"
+RN_ROOT="$RN_ROOT" "$(dirname "$0")/prepare-hermes.sh" "$CORE_OUT/hermes" "$lower"
+
+cmake -G Ninja -S "$ONE_MACOS/cpp" -B "$CORE_OUT/build" \
+  -DCMAKE_BUILD_TYPE="$config" \
+  -DCMAKE_OSX_ARCHITECTURES=arm64 \
+  -DCMAKE_OSX_DEPLOYMENT_TARGET=14.0 \
+  -DRN_ROOT="$RN_ROOT" \
+  -DNITRO_ROOT="$nitro_root" \
+  -DOPSQLITE_ROOT="$(dirname "$RN_ROOT")/@op-engineering/op-sqlite" \
+  -DWORKLETS_ROOT="$(dirname "$RN_ROOT")/react-native-worklets" \
+  -DHERMES_ROOT="$CORE_OUT/hermes/destroot" \
+  -DRN_DEPS_ROOT="$deps/packages/react-native/third-party" >/dev/null
+ninja -C "$CORE_OUT/build"

package/macos/template/macos/scripts/bundle-js.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Release builds embed the app's JavaScript as Hermes bytecode, main.jsbundle,
+# with its assets beside it, as the iOS bundle phase does. Debug builds load
+# from the dev server instead.
+#   $1  app root, the directory holding package.json
+#   $2  node_modules/react-native
+#   $3  hermesc from the extracted Hermes build the app links
+#   $4  the built app's resources directory
+set -eo pipefail
+
+if [ "${CONFIGURATION:-Debug}" = "Debug" ]; then
+  exit 0
+fi
+
+root="$1"
+rn_root="$2"
+hermesc="$3"
+resources="$4"
+mkdir -p "$resources"
+work="$(mktemp -d)"
+trap 'rm -rf "$work"' EXIT
+
+# shellcheck source=/dev/null
+source "$rn_root/scripts/node-binary.sh"
+
+cd "$root"
+"$NODE_BINARY" "$rn_root/cli.js" bundle --platform macos --dev false --minify true \
+  --bundle-output "$work/main.js" --assets-dest "$resources"
+"$hermesc" -emit-binary -max-diagnostic-width=80 -O -out "$resources/main.jsbundle" "$work/main.js"

package/macos/template/macos/scripts/embed-deps.sh

@@ -0,0 +1,20 @@
+#!/bin/bash
+# Embeds ReactNativeDependencies into the app. The macOS slice in RN's tarball
+# ships with its symlinks flattened into copies, which codesign rejects as an
+# ambiguous bundle, so rebuild the versioned layout here.
+set -euo pipefail
+
+src="$1/ReactNativeDependencies.xcframework/macos-arm64_x86_64/ReactNativeDependencies.framework"
+dst="$2/ReactNativeDependencies.framework"
+
+rm -rf "$dst"
+mkdir -p "$dst/Versions/A/Resources"
+cp "$src/Versions/A/ReactNativeDependencies" "$dst/Versions/A/"
+cp "$src/Versions/A/Resources/Info.plist" "$dst/Versions/A/Resources/"
+for bundle in "$src"/*.bundle; do
+  cp -R "$bundle" "$dst/Versions/A/Resources/"
+done
+ln -s A "$dst/Versions/Current"
+ln -s Versions/Current/ReactNativeDependencies "$dst/ReactNativeDependencies"
+ln -s Versions/Current/Resources "$dst/Resources"
+codesign --force --sign - "$dst"

package/macos/template/macos/scripts/embed-hermes.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+# Embeds hermesvm.framework from the extracted Hermes build into the app.
+set -euo pipefail
+
+src="$1/hermesvm.framework"
+dst="$2/hermesvm.framework"
+
+rm -rf "$dst"
+cp -R "$src" "$dst"
+codesign --force --sign - "$dst"

package/macos/template/macos/scripts/prepare-deps.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Extracts ReactNativeDependencies for the installed react-native into $1 and
+# prints nothing. The tarball comes from the ReactNative cache, then Maven.
+set -euo pipefail
+
+out="$1"
+rn_root="${RN_ROOT:?set RN_ROOT to node_modules/react-native}"
+version="$(node -p "require('$rn_root/package.json').version")"
+config="${2:-debug}"
+cache="$HOME/Library/Caches/ReactNative"
+tarball="$cache/reactnative-dependencies-$version-$config.tar.gz"
+
+# the extracted slice is only reusable for the react-native version it came from
+stamp="$out/.react-native-version"
+if [ -d "$out/packages/react-native/third-party/ReactNativeDependencies.xcframework" ] && [ "$(cat "$stamp" 2>/dev/null)" = "$version-$config" ]; then
+  exit 0
+fi
+rm -rf "$out/packages"
+
+if [ ! -f "$tarball" ]; then
+  mkdir -p "$cache"
+  url="https://repo1.maven.org/maven2/com/facebook/react/react-native-artifacts/$version/react-native-artifacts-$version-reactnative-dependencies-$config.tar.gz"
+  curl -fsSL "$url" -o "$tarball.part"
+  mv "$tarball.part" "$tarball"
+fi
+
+mkdir -p "$out"
+tar -xzf "$tarball" -C "$out"
+echo "$version-$config" > "$stamp"

package/macos/template/macos/scripts/prepare-hermes.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+# Extracts the Hermes build pinned by the installed react-native into $1. The
+# Maven tarball ships a macOS slice of hermesvm.framework next to the headers.
+set -euo pipefail
+
+out="$1"
+rn_root="${RN_ROOT:?set RN_ROOT to node_modules/react-native}"
+config="${2:-debug}"
+version="$(sed -n 's/^HERMES_VERSION_NAME=//p' "$rn_root/sdks/hermes-engine/version.properties")"
+cache="$HOME/Library/Caches/ReactNative"
+tarball="$cache/hermes-ios-$version-$config.tar.gz"
+
+# the extracted slice is only reusable for the Hermes build it came from
+stamp="$out/.hermes-version"
+if [ -d "$out/destroot/Library/Frameworks/macosx/hermesvm.framework" ] && [ "$(cat "$stamp" 2>/dev/null)" = "$version-$config" ]; then
+  exit 0
+fi
+rm -rf "$out/destroot"
+
+if [ ! -f "$tarball" ]; then
+  mkdir -p "$cache"
+  url="https://repo1.maven.org/maven2/com/facebook/hermes/hermes-ios/$version/hermes-ios-$version-hermes-ios-$config.tar.gz"
+  curl -fsSL "$url" -o "$tarball.part"
+  mv "$tarball.part" "$tarball"
+fi
+
+mkdir -p "$out"
+tar -xzf "$tarball" -C "$out"
+echo "$version-$config" > "$stamp"

package/native-core/host/OneHostCommandPredicate.h

@@ -0,0 +1,118 @@
+#pragma once
+
+#include <cctype>
+#include <cstring>
+#include <string>
+#include <vector>
+
+namespace facebook::react::commands {
+
+// key contexts share the same predicates on both desktop hosts.
+struct Predicate {
+  enum class Kind { Identifier, Not, And, Or };
+  Kind kind = Kind::Identifier;
+  std::string name;
+  std::vector<Predicate> operands;
+
+  bool matches(bool inputFocused) const
+  {
+    switch (kind) {
+      case Kind::Identifier:
+        return inputFocused && name == "Input";
+      case Kind::Not:
+        return !operands[0].matches(inputFocused);
+      case Kind::And:
+        return operands[0].matches(inputFocused) && operands[1].matches(inputFocused);
+      case Kind::Or:
+        return operands[0].matches(inputFocused) || operands[1].matches(inputFocused);
+    }
+    return false;
+  }
+};
+
+class PredicateParser {
+ public:
+  explicit PredicateParser(const std::string &source) : source_(source) {}
+
+  bool parse(Predicate &out, std::string &error)
+  {
+    if (!parseOr(out) || (skipSpace(), index_ != source_.size())) {
+      error = "unsupported context '" + source_ + "'";
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  const std::string &source_;
+  size_t index_ = 0;
+
+  void skipSpace()
+  {
+    while (index_ < source_.size() && source_[index_] == ' ') {
+      index_++;
+    }
+  }
+
+  bool take(const char *token)
+  {
+    skipSpace();
+    size_t length = strlen(token);
+    if (source_.compare(index_, length, token) != 0) {
+      return false;
+    }
+    index_ += length;
+    return true;
+  }
+
+  bool parseBinary(Predicate &out, Predicate::Kind kind, const char *token, bool (PredicateParser::*operand)(Predicate &))
+  {
+    if (!(this->*operand)(out)) {
+      return false;
+    }
+    while (take(token)) {
+      Predicate right;
+      if (!(this->*operand)(right)) {
+        return false;
+      }
+      Predicate joined;
+      joined.kind = kind;
+      joined.operands = {std::move(out), std::move(right)};
+      out = std::move(joined);
+    }
+    return true;
+  }
+
+  bool parseOr(Predicate &out) { return parseBinary(out, Predicate::Kind::Or, "||", &PredicateParser::parseAnd); }
+  bool parseAnd(Predicate &out) { return parseBinary(out, Predicate::Kind::And, "&&", &PredicateParser::parseUnary); }
+
+  bool parseUnary(Predicate &out)
+  {
+    // value comparisons are outside the desktop context contract
+    skipSpace();
+    if (source_.compare(index_, 2, "!=") != 0 && take("!")) {
+      Predicate operand;
+      if (!parseUnary(operand)) {
+        return false;
+      }
+      out.kind = Predicate::Kind::Not;
+      out.operands = {std::move(operand)};
+      return true;
+    }
+    if (take("(")) {
+      return parseOr(out) && take(")");
+    }
+    size_t start = index_;
+    while (index_ < source_.size() && (isalnum((unsigned char)source_[index_]) || source_[index_] == '_' || source_[index_] == '-')) {
+      index_++;
+    }
+    if (index_ == start) {
+      return false;
+    }
+    out.kind = Predicate::Kind::Identifier;
+    out.name = source_.substr(start, index_ - start);
+    return true;
+  }
+};
+
+} // namespace facebook::react::commands

package/native-core/host/OneHostModule.h

@@ -0,0 +1,125 @@
+#pragma once
+
+#include <ReactCommon/CallInvoker.h>
+#include <ReactCommon/TurboModule.h>
+#include <folly/dynamic.h>
+#include <jsi/JSIDynamic.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+namespace facebook::react {
+
+struct OneHostWindowMetrics {
+  double width{0};
+  double height{0};
+  double scale{1};
+};
+
+// What the TurboModules need from the host. Callbacks may run on any thread.
+// OneHostRuntime fills emitDeviceEvent and isJavaScriptQueue; the platform
+// fills the rest.
+struct OneHostModuleContext {
+  std::string scriptURL;
+  // PlatformConstants osVersion and interfaceIdiom, I18nManager localeIdentifier
+  std::string osVersion;
+  std::string interfaceIdiom;
+  std::string localeIdentifier;
+  std::function<OneHostWindowMetrics()> windowMetrics;
+  // "light" or "dark", the Appearance module's color scheme
+  std::function<std::string()> colorScheme;
+  // one line of host diagnostics, without a prefix
+  std::function<void(const std::string &line)> log;
+  // emits on RCTDeviceEventEmitter
+  std::function<void(const std::string &eventName, folly::dynamic payload)> emitDeviceEvent;
+  std::function<void()> reload;
+  std::function<bool()> isJavaScriptQueue;
+  // AppCommands.configure; returns an error for an invalid config
+  std::function<std::string(const folly::dynamic &config)> configureAppCommands;
+  // whether this runtime has an AppCommands listener
+  std::function<void(bool listening)> setAppCommandsListening;
+  // whether the host registers NativeAnimatedModule, so Animated runs on the
+  // C++ animated renderer
+  bool cxxNativeAnimated{false};
+};
+
+// A TurboModule made of host functions registered by name.
+class OneHostModule : public TurboModule {
+ public:
+  using Method = std::function<jsi::Value(jsi::Runtime &, const jsi::Value *, size_t)>;
+
+  OneHostModule(const std::string &name, std::shared_ptr<CallInvoker> jsInvoker)
+      : TurboModule(name, std::move(jsInvoker)) {}
+
+  // answers every unknown accessor with a no-op function, for modules whose JS
+  // side only ever calls into them
+  bool wildcard = false;
+  void method(const std::string &name, size_t argCount, Method method)
+  {
+    hostMethods_[name] = {argCount, std::move(method)};
+  }
+
+  // methods that need no result and no arguments
+  void noop(const std::string &name)
+  {
+    method(name, 0, [](jsi::Runtime &, const jsi::Value *, size_t) { return jsi::Value::undefined(); });
+  }
+
+  void constants(folly::dynamic value)
+  {
+    method("getConstants", 0, [value = std::move(value)](jsi::Runtime &rt, const jsi::Value *, size_t) {
+      return jsi::valueFromDynamic(rt, value);
+    });
+  }
+
+  jsi::Value create(jsi::Runtime &runtime, const jsi::PropNameID &propName) override
+  {
+    auto it = hostMethods_.find(propName.utf8(runtime));
+    if (it == hostMethods_.end()) {
+      if (wildcard) {
+        return jsi::Function::createFromHostFunction(runtime, propName, 0, [](jsi::Runtime &, const jsi::Value &, const jsi::Value *, size_t) { return jsi::Value::undefined(); });
+      }
+      return jsi::Value::undefined();
+    }
+    auto &entry = it->second;
+    return jsi::Function::createFromHostFunction(
+        runtime,
+        propName,
+        static_cast<unsigned int>(entry.first),
+        [method = entry.second](jsi::Runtime &rt, const jsi::Value &, const jsi::Value *args, size_t count) {
+          return method(rt, args, count);
+        });
+  }
+
+ private:
+  std::unordered_map<std::string, std::pair<size_t, Method>> hostMethods_;
+};
+
+inline std::string stringArg(jsi::Runtime &rt, const jsi::Value *args, size_t count, size_t index)
+{
+  if (index < count && args[index].isString()) {
+    return args[index].getString(rt).utf8(rt);
+  }
+  return {};
+}
+
+inline double numberArg(const jsi::Value *args, size_t count, size_t index)
+{
+  return index < count && args[index].isNumber() ? args[index].getNumber() : 0;
+}
+
+inline void addEventEmitterStubs(OneHostModule &module)
+{
+  module.noop("addListener");
+  module.noop("removeListeners");
+}
+
+inline jsi::Value resolvedPromise(jsi::Runtime &rt, jsi::Value value)
+{
+  auto resolve = rt.global().getPropertyAsObject(rt, "Promise").getPropertyAsFunction(rt, "resolve");
+  return resolve.call(rt, value);
+}
+
+} // namespace facebook::react