react-native-figma-shadow 0.1.0-alpha.1

package/cpp/figmashadow/Color.cpp

@@ -0,0 +1,225 @@
+#include "Color.h"
+
+#include <algorithm>
+#include <array>
+#include <cctype>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <string>
+#include <vector>
+
+namespace figmashadow {
+
+namespace {
+
+std::string toLower(std::string s) {
+  std::transform(s.begin(), s.end(), s.begin(),
+                 [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+  return s;
+}
+
+std::string trim(const std::string& s) {
+  size_t a = s.find_first_not_of(" \t\n\r\f\v");
+  if (a == std::string::npos) return "";
+  size_t b = s.find_last_not_of(" \t\n\r\f\v");
+  return s.substr(a, b - a + 1);
+}
+
+float clamp01(float v) { return v < 0.0f ? 0.0f : (v > 1.0f ? 1.0f : v); }
+
+bool hexNibble(char c, int& out) {
+  if (c >= '0' && c <= '9') { out = c - '0'; return true; }
+  c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+  if (c >= 'a' && c <= 'f') { out = c - 'a' + 10; return true; }
+  return false;
+}
+
+bool parseHex(const std::string& tok, Color& out) {
+  if (tok.empty() || tok[0] != '#') return false;
+  std::string h = tok.substr(1);
+  const size_t n = h.size();
+  if (n != 3 && n != 4 && n != 6 && n != 8) return false;
+
+  std::vector<int> nibbles;
+  nibbles.reserve(n);
+  for (char c : h) {
+    int v;
+    if (!hexNibble(c, v)) return false;
+    nibbles.push_back(v);
+  }
+
+  int r, g, b, a = 255;
+  if (n == 3 || n == 4) {
+    r = nibbles[0] * 17;
+    g = nibbles[1] * 17;
+    b = nibbles[2] * 17;
+    if (n == 4) a = nibbles[3] * 17;
+  } else {
+    r = nibbles[0] * 16 + nibbles[1];
+    g = nibbles[2] * 16 + nibbles[3];
+    b = nibbles[4] * 16 + nibbles[5];
+    if (n == 8) a = nibbles[6] * 16 + nibbles[7];
+  }
+  out.r = r / 255.0f;
+  out.g = g / 255.0f;
+  out.b = b / 255.0f;
+  out.a = a / 255.0f;
+  return true;
+}
+
+// Splits the inside of `rgb( ... )` on commas and/or whitespace (and an
+// optional `/` alpha separator), tolerating the modern and legacy syntaxes.
+std::vector<std::string> splitArgs(const std::string& inner) {
+  std::vector<std::string> parts;
+  std::string cur;
+  for (char c : inner) {
+    if (c == ',' || c == '/' || std::isspace(static_cast<unsigned char>(c))) {
+      if (!cur.empty()) { parts.push_back(cur); cur.clear(); }
+    } else {
+      cur.push_back(c);
+    }
+  }
+  if (!cur.empty()) parts.push_back(cur);
+  return parts;
+}
+
+// Parses a channel that is either `0..255` or a percentage `0..100%`.
+bool parseChannel(const std::string& s, float& out) {
+  if (s.empty()) return false;
+  char* end = nullptr;
+  double v = std::strtod(s.c_str(), &end);
+  if (end == s.c_str()) return false;
+  if (*end == '%') {
+    out = clamp01(static_cast<float>(v / 100.0));
+  } else {
+    out = clamp01(static_cast<float>(v / 255.0));
+  }
+  return true;
+}
+
+bool parseAlpha(const std::string& s, float& out) {
+  if (s.empty()) return false;
+  char* end = nullptr;
+  double v = std::strtod(s.c_str(), &end);
+  if (end == s.c_str()) return false;
+  if (*end == '%') v /= 100.0;
+  out = clamp01(static_cast<float>(v));
+  return true;
+}
+
+void hslToRgb(float h, float s, float l, Color& out) {
+  h = std::fmod(std::fmod(h, 360.0f) + 360.0f, 360.0f) / 360.0f;
+  auto hue = [](float p, float q, float t) {
+    if (t < 0.0f) t += 1.0f;
+    if (t > 1.0f) t -= 1.0f;
+    if (t < 1.0f / 6.0f) return p + (q - p) * 6.0f * t;
+    if (t < 1.0f / 2.0f) return q;
+    if (t < 2.0f / 3.0f) return p + (q - p) * (2.0f / 3.0f - t) * 6.0f;
+    return p;
+  };
+  if (s <= 0.0f) {
+    out.r = out.g = out.b = l;
+    return;
+  }
+  float q = l < 0.5f ? l * (1.0f + s) : l + s - l * s;
+  float p = 2.0f * l - q;
+  out.r = hue(p, q, h + 1.0f / 3.0f);
+  out.g = hue(p, q, h);
+  out.b = hue(p, q, h - 1.0f / 3.0f);
+}
+
+bool parseFunctional(const std::string& tok, Color& out) {
+  size_t open = tok.find('(');
+  if (open == std::string::npos || tok.back() != ')') return false;
+  std::string fn = toLower(tok.substr(0, open));
+  std::string inner = tok.substr(open + 1, tok.size() - open - 2);
+  auto args = splitArgs(inner);
+
+  if (fn == "rgb" || fn == "rgba") {
+    if (args.size() < 3) return false;
+    float r, g, b, a = 1.0f;
+    if (!parseChannel(args[0], r) || !parseChannel(args[1], g) ||
+        !parseChannel(args[2], b))
+      return false;
+    if (args.size() >= 4 && !parseAlpha(args[3], a)) return false;
+    out = {r, g, b, a};
+    return true;
+  }
+  if (fn == "hsl" || fn == "hsla") {
+    if (args.size() < 3) return false;
+    char* e = nullptr;
+    float h = static_cast<float>(std::strtod(args[0].c_str(), &e));
+    if (e == args[0].c_str()) return false;
+    auto pct = [](const std::string& s, float& v) {
+      char* end = nullptr;
+      double d = std::strtod(s.c_str(), &end);
+      if (end == s.c_str()) return false;
+      v = static_cast<float>(d / 100.0);
+      return true;
+    };
+    float s, l, a = 1.0f;
+    if (!pct(args[1], s) || !pct(args[2], l)) return false;
+    s = clamp01(s);
+    l = clamp01(l);
+    if (args.size() >= 4 && !parseAlpha(args[3], a)) return false;
+    hslToRgb(h, s, l, out);
+    out.a = a;
+    return true;
+  }
+  return false;
+}
+
+struct NamedColor {
+  const char* name;
+  uint32_t rgb;  // 0xRRGGBB
+};
+
+// The most common CSS named colors. rgb()/rgba()/hex cover the rest and are what
+// Figma and design tools actually emit.
+constexpr std::array<NamedColor, 34> kNamed = {{
+    {"black", 0x000000},   {"white", 0xffffff},   {"red", 0xff0000},
+    {"green", 0x008000},   {"blue", 0x0000ff},    {"yellow", 0xffff00},
+    {"cyan", 0x00ffff},    {"magenta", 0xff00ff}, {"gray", 0x808080},
+    {"grey", 0x808080},    {"silver", 0xc0c0c0},  {"maroon", 0x800000},
+    {"olive", 0x808000},   {"lime", 0x00ff00},    {"aqua", 0x00ffff},
+    {"teal", 0x008080},    {"navy", 0x000080},    {"fuchsia", 0xff00ff},
+    {"purple", 0x800080},  {"orange", 0xffa500},  {"pink", 0xffc0cb},
+    {"brown", 0xa52a2a},   {"gold", 0xffd700},    {"indigo", 0x4b0082},
+    {"violet", 0xee82ee},  {"crimson", 0xdc143c}, {"coral", 0xff7f50},
+    {"salmon", 0xfa8072},  {"khaki", 0xf0e68c},   {"lavender", 0xe6e6fa},
+    {"plum", 0xdda0dd},    {"orchid", 0xda70d6},  {"tan", 0xd2b48c},
+    {"turquoise", 0x40e0d0},
+}};
+
+}  // namespace
+
+bool parseColor(const std::string& raw, Color& out) {
+  std::string tok = trim(raw);
+  if (tok.empty()) return false;
+
+  if (tok[0] == '#') return parseHex(tok, out);
+  if (tok.find('(') != std::string::npos) return parseFunctional(tok, out);
+
+  std::string lower = toLower(tok);
+  if (lower == "transparent") {
+    out = {0.0f, 0.0f, 0.0f, 0.0f};
+    return true;
+  }
+  if (lower == "currentcolor") {
+    out = {0.0f, 0.0f, 0.0f, 1.0f};
+    return true;
+  }
+  for (const auto& nc : kNamed) {
+    if (lower == nc.name) {
+      out.r = ((nc.rgb >> 16) & 0xff) / 255.0f;
+      out.g = ((nc.rgb >> 8) & 0xff) / 255.0f;
+      out.b = (nc.rgb & 0xff) / 255.0f;
+      out.a = 1.0f;
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace figmashadow

package/cpp/figmashadow/Color.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <string>
+
+#include "Types.h"
+
+namespace figmashadow {
+
+// Parses a CSS color token: #rgb, #rgba, #rrggbb, #rrggbbaa, rgb()/rgba(),
+// hsl()/hsla(), `transparent`, `currentColor` (treated as opaque black) and the
+// common CSS named colors. Returns false if `token` is not a color.
+bool parseColor(const std::string& token, Color& out);
+
+}  // namespace figmashadow

package/cpp/figmashadow/FigmaShadow.cpp

@@ -0,0 +1,114 @@
+#include "FigmaShadow.h"
+
+#include <cmath>
+#include <cstdint>
+#include <list>
+#include <mutex>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+
+#include "Parser.h"
+#include "Rasterizer.h"
+
+namespace figmashadow {
+
+namespace {
+
+// Quantise floats to 1/8 px before hashing so sub-pixel layout jitter still
+// hits the cache.
+long quant(float v) { return std::lround(v * 8.0f); }
+
+std::string makeKey(float cw, float ch, float rtl, float rtr, float rbr, float rbl,
+                    const std::string& boxShadow, float bl, float bt, float br,
+                    float bb, float scale, bool hq) {
+  std::ostringstream os;
+  os << quant(cw) << '|' << quant(ch) << '|' << quant(rtl) << '|' << quant(rtr)
+     << '|' << quant(rbr) << '|' << quant(rbl) << '|' << quant(bl) << '|'
+     << quant(bt) << '|' << quant(br) << '|' << quant(bb) << '|' << quant(scale)
+     << '|' << (hq ? '1' : '0') << '|' << boxShadow;
+  return os.str();
+}
+
+constexpr size_t kMaxCacheBytes = 6 * 1024 * 1024;
+
+struct Cache {
+  std::mutex mutex;
+  std::list<std::pair<std::string, Bitmap>> items;  // front = most recent
+  std::unordered_map<std::string, decltype(items)::iterator> index;
+  size_t bytes = 0;
+
+  bool get(const std::string& key, Bitmap& out) {
+    std::lock_guard<std::mutex> lock(mutex);
+    auto it = index.find(key);
+    if (it == index.end()) return false;
+    items.splice(items.begin(), items, it->second);
+    out = it->second->second;
+    return true;
+  }
+
+  void put(const std::string& key, const Bitmap& bmp) {
+    std::lock_guard<std::mutex> lock(mutex);
+    if (index.count(key)) return;
+    items.emplace_front(key, bmp);
+    index[key] = items.begin();
+    bytes += bmp.pixels.size();
+    while (bytes > kMaxCacheBytes && items.size() > 1) {
+      auto& back = items.back();
+      bytes -= back.second.pixels.size();
+      index.erase(back.first);
+      items.pop_back();
+    }
+  }
+
+  void clear() {
+    std::lock_guard<std::mutex> lock(mutex);
+    items.clear();
+    index.clear();
+    bytes = 0;
+  }
+
+  size_t size() {
+    std::lock_guard<std::mutex> lock(mutex);
+    return bytes;
+  }
+};
+
+Cache& cache() {
+  static Cache instance;
+  return instance;
+}
+
+}  // namespace
+
+Bitmap render(float contentWidth, float contentHeight, float radiusTopLeft,
+              float radiusTopRight, float radiusBottomRight, float radiusBottomLeft,
+              const std::string& boxShadow, float bleedLeft, float bleedTop,
+              float bleedRight, float bleedBottom, float scale, bool highQuality) {
+  const std::string key =
+      makeKey(contentWidth, contentHeight, radiusTopLeft, radiusTopRight,
+              radiusBottomRight, radiusBottomLeft, boxShadow, bleedLeft, bleedTop,
+              bleedRight, bleedBottom, scale, highQuality);
+
+  Bitmap cached;
+  if (cache().get(key, cached)) return cached;
+
+  RenderRequest req;
+  req.contentWidth = contentWidth;
+  req.contentHeight = contentHeight;
+  req.radii = {radiusTopLeft, radiusTopRight, radiusBottomRight, radiusBottomLeft};
+  req.bleed = {bleedLeft, bleedTop, bleedRight, bleedBottom};
+  req.scale = scale;
+  req.highQuality = highQuality;
+  req.layers = parseBoxShadow(boxShadow);
+
+  Bitmap bmp = renderShadow(req);
+  if (!bmp.empty()) cache().put(key, bmp);
+  return bmp;
+}
+
+void clearCache() { cache().clear(); }
+
+size_t cacheSizeBytes() { return cache().size(); }
+
+}  // namespace figmashadow

package/cpp/figmashadow/FigmaShadow.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <string>
+
+#include "Types.h"
+
+namespace figmashadow {
+
+// High-level entry point used by both platform glue layers.
+//
+// Parses `boxShadow`, rasterizes every layer into one premultiplied RGBA8888
+// bitmap sized to (content + bleed) * scale device pixels, and memoizes the
+// result: identical requests (e.g. every row of a list) reuse one bitmap.
+//
+// `bleed*` must be the same values the JS layer used to inflate the native
+// view, so the bitmap lines up 1:1 with the view's pixels.
+Bitmap render(float contentWidth, float contentHeight,
+              float radiusTopLeft, float radiusTopRight,
+              float radiusBottomRight, float radiusBottomLeft,
+              const std::string& boxShadow,
+              float bleedLeft, float bleedTop, float bleedRight, float bleedBottom,
+              float scale, bool highQuality = false);
+
+// Drops every memoized bitmap. Call on a memory warning.
+void clearCache();
+
+// Approximate number of bytes held by the cache.
+size_t cacheSizeBytes();
+
+}  // namespace figmashadow

package/cpp/figmashadow/Parser.cpp

@@ -0,0 +1,150 @@
+#include "Parser.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstdlib>
+
+#include "Color.h"
+
+namespace figmashadow {
+
+namespace {
+
+std::string trim(const std::string& s) {
+  size_t a = s.find_first_not_of(" \t\n\r\f\v");
+  if (a == std::string::npos) return "";
+  size_t b = s.find_last_not_of(" \t\n\r\f\v");
+  return s.substr(a, b - a + 1);
+}
+
+std::string toLower(std::string s) {
+  std::transform(s.begin(), s.end(), s.begin(),
+                 [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+  return s;
+}
+
+// Splits on the given delimiter, ignoring delimiters nested inside parentheses
+// (so `rgba(0, 0, 0, .5)` survives a comma split).
+std::vector<std::string> splitTopLevel(const std::string& s, char delim) {
+  std::vector<std::string> out;
+  std::string cur;
+  int depth = 0;
+  for (char c : s) {
+    if (c == '(') depth++;
+    else if (c == ')') depth = std::max(0, depth - 1);
+
+    if (c == delim && depth == 0) {
+      out.push_back(cur);
+      cur.clear();
+    } else {
+      cur.push_back(c);
+    }
+  }
+  out.push_back(cur);
+  return out;
+}
+
+// Whitespace tokenizer that keeps `fn( ... )` groups intact.
+std::vector<std::string> tokenize(const std::string& s) {
+  std::vector<std::string> out;
+  std::string cur;
+  int depth = 0;
+  for (char c : s) {
+    if (c == '(') depth++;
+    else if (c == ')') depth = std::max(0, depth - 1);
+
+    if (std::isspace(static_cast<unsigned char>(c)) && depth == 0) {
+      if (!cur.empty()) { out.push_back(cur); cur.clear(); }
+    } else {
+      cur.push_back(c);
+    }
+  }
+  if (!cur.empty()) out.push_back(cur);
+  return out;
+}
+
+// Parses a CSS length. Accepts a bare number or one suffixed with `px`/`dp`/`pt`
+// (all treated as logical px). Rejects other units so they don't get mistaken
+// for offsets.
+bool parseLength(const std::string& tok, float& out) {
+  if (tok.empty()) return false;
+  char* end = nullptr;
+  double v = std::strtod(tok.c_str(), &end);
+  if (end == tok.c_str()) return false;
+  std::string unit = toLower(trim(std::string(end)));
+  if (unit.empty() || unit == "px" || unit == "dp" || unit == "dip" || unit == "pt") {
+    out = static_cast<float>(v);
+    return true;
+  }
+  return false;
+}
+
+ShadowLayer parseLayer(const std::string& raw, bool& ok) {
+  ShadowLayer layer;
+  ok = false;
+
+  std::vector<float> lengths;
+  bool hasColor = false;
+
+  for (const auto& tok : tokenize(raw)) {
+    std::string lower = toLower(tok);
+    if (lower == "inset") {
+      layer.inset = true;
+      continue;
+    }
+    float len;
+    Color color;
+    // A bare number is always a length; try length before color so tokens like
+    // `0` aren't swallowed by a lenient color parser.
+    if (parseLength(tok, len)) {
+      lengths.push_back(len);
+    } else if (!hasColor && parseColor(tok, color)) {
+      layer.color = color;
+      hasColor = true;
+    } else {
+      // Unknown token: ignore it rather than dropping the whole layer.
+    }
+  }
+
+  if (lengths.size() < 2) return layer;
+
+  layer.offsetX = lengths[0];
+  layer.offsetY = lengths[1];
+  if (lengths.size() >= 3) layer.blur = std::max(0.0f, lengths[2]);
+  if (lengths.size() >= 4) layer.spread = lengths[3];
+  if (!hasColor) layer.color = {0.0f, 0.0f, 0.0f, 1.0f};  // CSS default is currentColor
+
+  ok = true;
+  return layer;
+}
+
+}  // namespace
+
+std::vector<ShadowLayer> parseBoxShadow(const std::string& input) {
+  std::string s = trim(input);
+
+  // Strip an optional `box-shadow:` / `boxShadow:` prefix.
+  size_t colon = s.find(':');
+  if (colon != std::string::npos) {
+    std::string head = toLower(trim(s.substr(0, colon)));
+    if (head == "box-shadow" || head == "boxshadow") {
+      s = trim(s.substr(colon + 1));
+    }
+  }
+  if (!s.empty() && s.back() == ';') s.pop_back();
+  s = trim(s);
+
+  std::vector<ShadowLayer> layers;
+  if (s.empty() || toLower(s) == "none") return layers;
+
+  for (const auto& part : splitTopLevel(s, ',')) {
+    std::string layerStr = trim(part);
+    if (layerStr.empty()) continue;
+    bool ok = false;
+    ShadowLayer layer = parseLayer(layerStr, ok);
+    if (ok) layers.push_back(layer);
+  }
+  return layers;
+}
+
+}  // namespace figmashadow

package/cpp/figmashadow/Parser.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "Types.h"
+
+namespace figmashadow {
+
+// Parses a CSS `box-shadow` value into layers, in source order (the first layer
+// paints on top). Tolerates a leading `box-shadow:` and a trailing `;`, the
+// `inset` keyword in any position, 2-4 lengths, and a color token anywhere in
+// the declaration. Unparseable layers are skipped.
+std::vector<ShadowLayer> parseBoxShadow(const std::string& input);
+
+}  // namespace figmashadow