react-native-windows 0.81.34 → 0.81.35

package/external/folly/folly/json/json.h

@@ -0,0 +1,238 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+//
+// Docs: https://fburl.com/fbcref_json
+//
+
+/**
+ * Serialize and deserialize folly::dynamic values as JSON.
+ *
+ * Basic JSON type system:
+ *
+ *     Value  : String | Bool | Null | Object | Array | Number
+ *     String : UTF-8 sequence
+ *     Object : (String, Value) pairs, with unique String keys
+ *     Array  : ordered list of Values
+ *     Null   : null
+ *     Bool   : true | false
+ *     Number : (representation unspecified)
+ *
+ * For more information see http://json.org or look up RFC 4627.
+ *
+ * If your dynamic has anything illegal with regard to this type
+ * system, the serializer will throw.
+ *
+ * @file json.h
+ */
+
+#pragma once
+
+#include <iosfwd>
+#include <string>
+
+#include <folly/Function.h>
+#include <folly/Range.h>
+#include <folly/json/dynamic.h>
+
+namespace folly {
+
+//////////////////////////////////////////////////////////////////////
+
+namespace json {
+
+struct serialization_opts {
+  // If true, keys in an object can be non-strings.  (In strict
+  // JSON, object keys must be strings.)  This is used by dynamic's
+  // operator<<.
+  bool allow_non_string_keys{false};
+
+  // If true, integer keys are allowed irrespective of 'allow_non_string_keys'
+  // in parsing, and are converted to strings in serialization. Other types are
+  // accepted accoring to 'allow_non_string_keys'. If set, validate_keys is
+  // enabled. Any key sorting will be applied on the stored integers, if present
+  // in the input object.
+  bool convert_int_keys{false};
+
+  /*
+   * If true, refuse to serialize 64-bit numbers that cannot be
+   * precisely represented by fit a double---instead, throws an
+   * exception if the document contains this.
+   */
+  bool javascript_safe{false};
+
+  // If true, the serialized json will contain space and newlines to
+  // try to be minimally "pretty".
+  bool pretty_formatting{false};
+
+  // The number of spaces to indent by when pretty_formatting is enabled.
+  unsigned int pretty_formatting_indent_width{2};
+
+  // If true, non-ASCII utf8 characters would be encoded as \uXXXX:
+  // - if the code point is in [U+0000..U+FFFF] => encode as a single \uXXXX
+  // - if the code point is > U+FFFF => encode as 2 UTF-16 surrogate pairs.
+  bool encode_non_ascii{false};
+
+  // Check that strings are valid utf8
+  bool validate_utf8{false};
+
+  // Check that keys are distinct
+  bool validate_keys{false};
+
+  // Allow trailing comma in lists of values / items
+  bool allow_trailing_comma{false};
+
+  // Sort keys of all objects before printing out (potentially slow)
+  // using dynamic::operator<.
+  // Has no effect if sort_keys_by is set.
+  bool sort_keys{false};
+
+  // Sort keys of all objects before printing out (potentially slow)
+  // using the provided less functor.
+  Function<bool(dynamic const&, dynamic const&) const> sort_keys_by;
+
+  // Replace invalid utf8 characters with U+FFFD and continue
+  bool skip_invalid_utf8{false};
+
+  // true to allow NaN or INF values
+  bool allow_nan_inf{false};
+
+  // Options for how to print floating point values.  See Conv.h
+  // toAppend implementation for floating point for more info
+  folly::DtoaMode dtoa_mode{};
+
+  unsigned int double_num_digits{0}; // ignored when mode is SHORTEST*
+
+  folly::DtoaFlags dtoa_flags{};
+
+  // Fallback to double when a value that looks like integer is too big to
+  // fit in an int64_t. Can result in loss a of precision.
+  bool double_fallback{false};
+
+  // Do not parse numbers. Instead, store them as strings and leave the
+  // conversion up to the user.
+  bool parse_numbers_as_strings{false};
+
+  // Recursion limit when parsing.
+  unsigned int recursion_limit{100};
+
+  // Bitmap representing ASCII characters to escape with unicode
+  // representations. The least significant bit of the first in the pair is
+  // ASCII value 0; the most significant bit of the second in the pair is ASCII
+  // value 127. Some specific characters in this range are always escaped
+  // regardless of the bitmask - namely characters less than 0x20, \, and ".
+  std::array<uint64_t, 2> extra_ascii_to_escape_bitmap{};
+};
+
+/**
+ * Create bitmap for serialization_opts.extra_ascii_to_escape_bitmap.
+ *
+ * Generates a bitmap with bits set for each of the ASCII characters provided
+ * for use in the serialization_opts extra_ascii_to_escape_bitmap option. If any
+ * characters are not valid ASCII, they are ignored.
+ */
+std::array<uint64_t, 2> buildExtraAsciiToEscapeBitmap(StringPiece chars);
+
+/**
+ * Serialize dynamic to json-string, with options.
+ *
+ * Main JSON serialization routine taking folly::dynamic parameters.
+ * For the most common use cases there are simpler functions in the
+ * main folly namespace.
+ */
+std::string serialize(dynamic const&, serialization_opts const&);
+
+/**
+ * Escape a string so that it is legal to print it in JSON text.
+ *
+ * Append the result to out.
+ */
+void escapeString(
+    StringPiece input, std::string& out, const serialization_opts& opts);
+
+/**
+ * Strip all C99-like comments (i.e. // and / * ... * /)
+ */
+std::string stripComments(StringPiece jsonC);
+
+// Parse error can be thrown when deserializing json (ie., converting string
+// into json).
+class FOLLY_EXPORT parse_error : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+};
+
+// Print error can be thrown when serializing json (ie., converting json into
+// string).
+class FOLLY_EXPORT print_error : public std::runtime_error {
+ public:
+  using std::runtime_error::runtime_error;
+};
+
+// may be extened in future to include offset, col, etc.
+struct parse_location {
+  uint32_t line{}; // 0-indexed
+};
+
+// may be extended in future to include end location
+struct parse_range {
+  parse_location begin;
+};
+
+struct parse_metadata {
+  parse_range key_range;
+  parse_range value_range;
+};
+
+using metadata_map = std::unordered_map<dynamic const*, parse_metadata>;
+
+} // namespace json
+
+//////////////////////////////////////////////////////////////////////
+
+/**
+ * Parse a json blob out of a range and produce a dynamic representing
+ * it.
+ */
+dynamic parseJson(StringPiece, json::serialization_opts const&);
+dynamic parseJson(StringPiece);
+
+dynamic parseJsonWithMetadata(StringPiece range, json::metadata_map* map);
+dynamic parseJsonWithMetadata(
+    StringPiece range,
+    json::serialization_opts const& opts,
+    json::metadata_map* map);
+
+/**
+ * Serialize a dynamic into a json string.
+ */
+std::string toJson(dynamic const&);
+
+/**
+ * Serialize a dynamic into a json string with indentation.
+ * Note that the keys of all objects will be sorted.
+ */
+std::string toPrettyJson(dynamic const&);
+
+/**
+ * Printer for GTest.
+ *
+ * Uppercase name to fill GTest's API, which calls this method through ADL.
+ */
+void PrintTo(const dynamic&, std::ostream*);
+//////////////////////////////////////////////////////////////////////
+
+} // namespace folly

package/external/folly/folly/json/json_patch.cpp

@@ -0,0 +1,325 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/json/json_patch.h>
+
+#include <glog/logging.h>
+
+#include <folly/container/Enumerate.h>
+
+namespace folly {
+
+// JSON patch operation names
+constexpr StringPiece kOperationTest = "test";
+constexpr StringPiece kOperationRemove = "remove";
+constexpr StringPiece kOperationAdd = "add";
+constexpr StringPiece kOperationReplace = "replace";
+constexpr StringPiece kOperationMove = "move";
+constexpr StringPiece kOperationCopy = "copy";
+// field tags in JSON patch
+constexpr StringPiece kOpTag = "op";
+constexpr StringPiece kValueTag = "value";
+constexpr StringPiece kPathTag = "path";
+constexpr StringPiece kFromTag = "from";
+
+// static
+Expected<json_patch, json_patch::parse_error> json_patch::try_parse(
+    dynamic const& obj) noexcept {
+  using err_code = parse_error_code;
+
+  json_patch patch;
+  if (!obj.isArray()) {
+    return makeUnexpected(parse_error{err_code::invalid_shape, &obj});
+  }
+  for (auto const& elem : obj) {
+    if (!elem.isObject()) {
+      return makeUnexpected(parse_error{err_code::invalid_shape, &elem});
+    }
+    auto const* op_ptr = elem.get_ptr(kOpTag);
+    if (!op_ptr) {
+      return makeUnexpected(parse_error{err_code::missing_op, &elem});
+    }
+    if (!op_ptr->isString()) {
+      return makeUnexpected(parse_error{err_code::malformed_op, &elem});
+    }
+    auto const op_str = op_ptr->asString();
+    patch_operation op;
+
+    // extract 'from' attribute
+    {
+      auto const* from_ptr = elem.get_ptr(kFromTag);
+      if (from_ptr) {
+        if (!from_ptr->isString()) {
+          return makeUnexpected(parse_error{err_code::invalid_shape, &elem});
+        }
+        auto json_ptr = json_pointer::try_parse(from_ptr->asString());
+        if (!json_ptr.hasValue()) {
+          return makeUnexpected(
+              parse_error{err_code::malformed_from_attr, &elem});
+        }
+        op.from = json_ptr.value();
+      }
+    }
+
+    // extract 'path' attribute
+    {
+      auto const* path_ptr = elem.get_ptr(kPathTag);
+      if (!path_ptr) {
+        return makeUnexpected(parse_error{err_code::missing_path_attr, &elem});
+      }
+      if (!path_ptr->isString()) {
+        return makeUnexpected(
+            parse_error{err_code::malformed_path_attr, &elem});
+      }
+      auto const json_ptr = json_pointer::try_parse(path_ptr->asString());
+      if (!json_ptr.hasValue()) {
+        return makeUnexpected(
+            parse_error{err_code::malformed_path_attr, &elem});
+      }
+      op.path = json_ptr.value();
+    }
+
+    // extract 'value' attribute
+    {
+      auto const* val_ptr = elem.get_ptr(kValueTag);
+      if (val_ptr) {
+        op.value = *val_ptr;
+      }
+    }
+
+    // check mandatory attributes - different per operation
+    // NOTE: per RFC, the surplus attributes (e.g. 'from' with 'add')
+    // should be simply ignored
+
+    using op_code = patch_operation_code;
+
+    if (op_str == kOperationTest) {
+      if (!op.value) {
+        return makeUnexpected(parse_error{err_code::missing_value_attr, &elem});
+      }
+      op.op_code = op_code::test;
+    } else if (op_str == kOperationRemove) {
+      op.op_code = op_code::remove;
+    } else if (op_str == kOperationAdd) {
+      if (!op.value) {
+        return makeUnexpected(parse_error{err_code::missing_value_attr, &elem});
+      }
+      op.op_code = op_code::add;
+    } else if (op_str == kOperationReplace) {
+      if (!op.value) {
+        return makeUnexpected(parse_error{err_code::missing_value_attr, &elem});
+      }
+      op.op_code = op_code::replace;
+    } else if (op_str == kOperationMove) {
+      if (!op.from) {
+        return makeUnexpected(parse_error{err_code::missing_from_attr, &elem});
+      }
+      // is from a proper prefix to path?
+      if (op.from->is_prefix_of(op.path)) {
+        return makeUnexpected(
+            parse_error{err_code::overlapping_pointers, &elem});
+      }
+      op.op_code = op_code::move;
+    } else if (op_str == kOperationCopy) {
+      if (!op.from) {
+        return makeUnexpected(parse_error{err_code::missing_from_attr, &elem});
+      }
+      op.op_code = op_code::copy;
+    }
+
+    if (op.op_code != op_code::invalid) {
+      patch.ops_.emplace_back(std::move(op));
+    } else {
+      return makeUnexpected(parse_error{err_code::unknown_op, &elem});
+    }
+  }
+  return patch;
+}
+
+std::vector<json_patch::patch_operation> const& json_patch::ops() const {
+  return ops_;
+}
+
+namespace {
+
+// clang-format off
+Expected<Unit, json_patch::patch_application_error_code>
+// clang-format on
+do_remove(dynamic::resolved_json_pointer<dynamic>& ptr) {
+  using error_code = json_patch::patch_application_error_code;
+
+  if (!ptr.hasValue()) {
+    return makeUnexpected(error_code::path_not_found);
+  }
+
+  auto parent = ptr->parent;
+
+  if (!parent) {
+    return makeUnexpected(error_code::other);
+  }
+
+  if (parent->isObject()) {
+    parent->erase(ptr->parent_key);
+    return unit;
+  }
+
+  if (parent->isArray()) {
+    parent->erase(parent->begin() + ptr->parent_index);
+    return unit;
+  }
+
+  return makeUnexpected(error_code::other);
+}
+
+// clang-format off
+Expected<Unit, json_patch::patch_application_error_code>
+// clang-format on
+do_add(
+    dynamic::resolved_json_pointer<dynamic>& ptr,
+    const dynamic& value,
+    const std::string& last_token) {
+  using app_err_code = json_patch::patch_application_error_code;
+  using res_err_code = dynamic::json_pointer_resolution_error_code;
+
+  // element found: see if parent is object or array
+  if (ptr.hasValue()) {
+    // root element, or key in object - replace (per RFC)
+    if (ptr->parent == nullptr || ptr->parent->isObject()) {
+      *ptr->value = value;
+    }
+    // valid index in array: insert at index and shift right
+    if (ptr->parent && ptr->parent->isArray()) {
+      ptr->parent->insert(ptr->parent->begin() + ptr->parent_index, value);
+    }
+  } else {
+    // see if we can add value, based on pointer resolution state
+    switch (ptr.error().error_code) {
+      // key not found. can only happen in object - add new key-value
+      case res_err_code::key_not_found: {
+        DCHECK(ptr.error().context->isObject());
+        ptr.error().context->insert(last_token, value);
+        break;
+      }
+      // special '-' index in array - do append operation
+      case res_err_code::append_requested: {
+        DCHECK(ptr.error().context->isArray());
+        ptr.error().context->push_back(value);
+        break;
+      }
+      case res_err_code::other:
+      case res_err_code::index_out_of_bounds:
+      case res_err_code::index_not_numeric:
+      case res_err_code::index_has_leading_zero:
+      case res_err_code::element_not_object_or_array:
+      case res_err_code::json_pointer_out_of_bounds:
+      default:
+        return makeUnexpected(app_err_code::other);
+    }
+  }
+  return unit;
+}
+} // namespace
+
+// clang-format off
+Expected<Unit, json_patch::patch_application_error>
+// clang-format on
+json_patch::apply(dynamic& obj) const {
+  using op_code = patch_operation_code;
+  using error_code = patch_application_error_code;
+  using error = patch_application_error;
+
+  for (auto&& [index, op] : enumerate(ops_)) {
+    auto resolved_path = obj.try_get_ptr(op.path);
+
+    switch (op.op_code) {
+      case op_code::test:
+        if (!resolved_path.hasValue()) {
+          return makeUnexpected(error{error_code::path_not_found, index});
+        }
+        if (*resolved_path->value != *op.value) {
+          return makeUnexpected(error{error_code::test_failed, index});
+        }
+        break;
+      case op_code::remove: {
+        auto ret = do_remove(resolved_path);
+        if (ret.hasError()) {
+          return makeUnexpected(error{ret.error(), index});
+        }
+        break;
+      }
+      case op_code::add: {
+        DCHECK(op.value.has_value());
+        auto ret = do_add(resolved_path, *op.value, op.path.tokens().back());
+        if (ret.hasError()) {
+          return makeUnexpected(error{ret.error(), index});
+        }
+        break;
+      }
+      case op_code::replace: {
+        if (resolved_path.hasValue()) {
+          *resolved_path->value = *op.value;
+        } else {
+          return makeUnexpected(error{error_code::path_not_found, index});
+        }
+        break;
+      }
+      case op_code::move: {
+        DCHECK(op.from.has_value());
+        auto resolved_from = obj.try_get_ptr(*op.from);
+        if (!resolved_from.hasValue()) {
+          return makeUnexpected(error{error_code::from_not_found, index});
+        }
+        {
+          auto ret = do_add(
+              resolved_path, *resolved_from->value, op.path.tokens().back());
+          if (ret.hasError()) {
+            return makeUnexpected(error{ret.error(), index});
+          }
+        }
+        {
+          auto ret = do_remove(resolved_from);
+          if (ret.hasError()) {
+            return makeUnexpected(error{ret.error(), index});
+          }
+        }
+        break;
+      }
+      case op_code::copy: {
+        DCHECK(op.from.has_value());
+        auto const resolved_from = obj.try_get_ptr(*op.from);
+        if (!resolved_from.hasValue()) {
+          return makeUnexpected(error{error_code::from_not_found, index});
+        }
+        {
+          DCHECK(!op.path.tokens().empty());
+          auto ret = do_add(
+              resolved_path, *resolved_from->value, op.path.tokens().back());
+          if (ret.hasError()) {
+            return makeUnexpected(error{ret.error(), index});
+          }
+        }
+        break;
+      }
+      case op_code::invalid: {
+        DCHECK(false);
+        return makeUnexpected(error{error_code::other, index});
+      }
+    }
+  }
+  return unit;
+}
+
+} // namespace folly

package/external/folly/folly/json/json_patch.h

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <vector>
+
+#include <folly/Expected.h>
+#include <folly/Optional.h>
+#include <folly/json/dynamic.h>
+#include <folly/json_pointer.h>
+
+namespace folly {
+
+/*
+ * json_patch
+ *
+ * As described in RFC 6902 "JSON Patch".
+ *
+ * Implements parsing. Application over data structures must be
+ * implemented separately.
+ */
+class json_patch {
+ public:
+  enum class parse_error_code : uint8_t {
+    undefined,
+    invalid_shape,
+    missing_op,
+    unknown_op,
+    malformed_op,
+    missing_path_attr,
+    malformed_path_attr,
+    missing_from_attr,
+    malformed_from_attr,
+    missing_value_attr,
+    overlapping_pointers,
+  };
+
+  /*
+   * If parsing JSON patch object fails we return err code along with
+   * pointer to part of JSON document that we could not parse
+   */
+  struct parse_error {
+    // one of the above error codes
+    parse_error_code error_code{parse_error_code::undefined};
+    // pointer to object that caused the error
+    dynamic const* obj{};
+  };
+
+  enum class patch_operation_code : uint8_t {
+    invalid = 0,
+    test,
+    remove,
+    add,
+    replace,
+    move,
+    copy,
+  };
+
+  /*
+   * Single JSON patch operation. Argument may vary based on op type
+   */
+  struct patch_operation {
+    patch_operation_code op_code{patch_operation_code::invalid};
+    json_pointer path;
+    Optional<json_pointer> from;
+    Optional<dynamic> value;
+    friend bool operator==(
+        patch_operation const& lhs, patch_operation const& rhs) {
+      return lhs.op_code == rhs.op_code && lhs.path == rhs.path &&
+          lhs.from == rhs.from && lhs.value == rhs.value;
+    }
+    friend bool operator!=(
+        patch_operation const& lhs, patch_operation const& rhs) {
+      return !(lhs == rhs);
+    }
+  };
+
+  json_patch() = default;
+  ~json_patch() = default;
+
+  static Expected<json_patch, parse_error> try_parse(
+      dynamic const& obj) noexcept;
+
+  std::vector<patch_operation> const& ops() const;
+
+  enum class patch_application_error_code : uint8_t {
+    other,
+    // "from" pointer did not resolve
+    from_not_found,
+    // "path" pointer did not resolve
+    path_not_found,
+    // "test" condition failed
+    test_failed,
+  };
+
+  struct patch_application_error {
+    patch_application_error_code error_code{};
+    // index of the patch element (in array) that caused error
+    size_t index{};
+  };
+
+  /*
+   * Mutate supplied object in accordance with patch operations. Leaves
+   * object in partially modified state if one of the operations fails.
+   */
+  Expected<Unit, patch_application_error> apply(dynamic& obj) const;
+
+ private:
+  std::vector<patch_operation> ops_;
+};
+
+} // namespace folly