@shopify/react-native-skia 0.1.129 → 0.1.132

package/cpp/skia/include/sksl/SkSLPosition.h

@@ -0,0 +1,102 @@
+/*
+ * Copyright 2021 Google LLC.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SKSL_POSITION
+#define SKSL_POSITION
+
+#include "include/core/SkTypes.h"
+#include <string_view>
+
+namespace SkSL {
+
+class Position {
+public:
+    Position()
+        : fStartOffset(-1)
+        , fLength(0) {}
+
+    static Position Range(int startOffset, int endOffset) {
+        SkASSERT(startOffset <= endOffset);
+        SkASSERT(startOffset <= 0xFFFFFF);
+        int length = endOffset - startOffset;
+        Position result;
+        result.fStartOffset = startOffset;
+        result.fLength = length <= 0xFF ? length : 0xFF;
+        return result;
+    }
+
+    bool valid() const {
+        return fStartOffset != -1;
+    }
+
+    int line(std::string_view source) const;
+
+    int startOffset() const {
+        SkASSERT(this->valid());
+        return fStartOffset;
+    }
+
+    int endOffset() const {
+        SkASSERT(this->valid());
+        return fStartOffset + fLength;
+    }
+
+    // Returns the position from this through, and including the entirety of, end.
+    Position rangeThrough(Position end) const {
+        if (fStartOffset == -1 || end.fStartOffset == -1) {
+            return *this;
+        }
+        SkASSERTF(this->startOffset() <= end.startOffset() && this->endOffset() <= end.endOffset(),
+                "Invalid range: (%d-%d) - (%d-%d)\n", this->startOffset(), this->endOffset(),
+                end.startOffset(), end.endOffset());
+        return Range(this->startOffset(), end.endOffset());
+    }
+
+    // Returns a position representing the character immediately after this position
+    Position after() const {
+        int endOffset = this->endOffset();
+        return Range(endOffset, endOffset + 1);
+    }
+
+    bool operator==(const Position& other) const {
+        return fStartOffset == other.fStartOffset && fLength == other.fLength;
+    }
+
+    bool operator!=(const Position& other) const {
+        return !(*this == other);
+    }
+
+    bool operator>(const Position& other) const {
+        return fStartOffset > other.fStartOffset;
+    }
+
+    bool operator>=(const Position& other) const {
+        return fStartOffset >= other.fStartOffset;
+    }
+
+    bool operator<(const Position& other) const {
+        return fStartOffset < other.fStartOffset;
+    }
+
+    bool operator<=(const Position& other) const {
+        return fStartOffset <= other.fStartOffset;
+    }
+
+private:
+    int32_t fStartOffset : 24;
+    uint32_t fLength : 8;
+};
+
+struct ForLoopPositions {
+    Position initPosition = Position();
+    Position conditionPosition = Position();
+    Position nextPosition = Position();
+};
+
+} // namespace SkSL
+
+#endif

package/cpp/skia/include/svg/SkSVGCanvas.h

@@ -8,9 +8,13 @@
 #ifndef SkSVGCanvas_DEFINED
 #define SkSVGCanvas_DEFINED
 
-#include "include/core/SkCanvas.h"
+#include "include/core/SkTypes.h"
 
+#include <memory>
+
+class SkCanvas;
 class SkWStream;
+struct SkRect;
 
 class SK_API SkSVGCanvas {
 public:

package/cpp/skia/include/utils/SkAnimCodecPlayer.h

@@ -9,6 +9,13 @@
 #define SkAnimCodecPlayer_DEFINED
 
 #include "include/codec/SkCodec.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSize.h"
+
+#include <stdint.h>
+#include <memory>
+#include <vector>
 
 class SkImage;
 

package/cpp/skia/include/utils/SkCamera.h

@@ -12,6 +12,8 @@
 
 #include "include/core/SkM44.h"
 #include "include/core/SkMatrix.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 #include "include/private/SkNoncopyable.h"
 
 // NOTE -- This entire header / impl is deprecated, and will be removed from Skia soon.

package/cpp/skia/include/utils/SkCanvasStateUtils.h

@@ -8,8 +8,11 @@
 #ifndef SkCanvasStateUtils_DEFINED
 #define SkCanvasStateUtils_DEFINED
 
-#include "include/core/SkCanvas.h"
+#include "include/core/SkTypes.h"
 
+#include <memory>
+
+class SkCanvas;
 class SkCanvasState;
 
 /**

package/cpp/skia/include/utils/SkCustomTypeface.h

@@ -10,15 +10,17 @@
 
 #include "include/core/SkFontMetrics.h"
 #include "include/core/SkFontStyle.h"
-#include "include/core/SkImage.h"
-#include "include/core/SkPaint.h"
 #include "include/core/SkPath.h"
-#include "include/core/SkPicture.h"
-#include "include/core/SkTypeface.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
 
 #include <vector>
 
+class SkImage;
+class SkPaint;
+class SkPicture;
 class SkStream;
+class SkTypeface;
 
 class SkCustomTypefaceBuilder {
 public:

package/cpp/skia/include/utils/SkNWayCanvas.h

@@ -9,10 +9,41 @@
 #ifndef SkNWayCanvas_DEFINED
 #define SkNWayCanvas_DEFINED
 
+#include "include/core/SkBlendMode.h"
+#include "include/core/SkCanvas.h"
 #include "include/core/SkCanvasVirtualEnforcer.h"
+#include "include/core/SkClipOp.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkM44.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSamplingOptions.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 #include "include/private/SkTDArray.h"
 #include "include/utils/SkNoDrawCanvas.h"
 
+class SkData;
+class SkDrawable;
+class SkGlyphRunList;
+class SkImage;
+class SkMatrix;
+class SkPaint;
+class SkPath;
+class SkPicture;
+class SkRRect;
+class SkRegion;
+class SkShader;
+class SkTextBlob;
+class SkVertices;
+struct SkDrawShadowRec;
+struct SkPoint;
+struct SkRSXform;
+struct SkRect;
+
+#if SK_SUPPORT_GPU
+class GrSlug;
+#endif
+
 class SK_API SkNWayCanvas : public SkCanvasVirtualEnforcer<SkNoDrawCanvas> {
 public:
     SkNWayCanvas(int width, int height);
@@ -39,6 +70,9 @@ protected:
     void onDrawGlyphRunList(const SkGlyphRunList&, const SkPaint&) override;
     void onDrawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
                         const SkPaint& paint) override;
+#if SK_SUPPORT_GPU
+    void onDrawSlug(const GrSlug* slug) override;
+#endif
     void onDrawPatch(const SkPoint cubics[12], const SkColor colors[4],
                      const SkPoint texCoords[4], SkBlendMode, const SkPaint& paint) override;
 

package/cpp/skia/include/utils/SkNullCanvas.h

@@ -8,7 +8,11 @@
 #ifndef SkNullCanvas_DEFINED
 #define SkNullCanvas_DEFINED
 
-#include "include/core/SkCanvas.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
+
+class SkCanvas;
 
 /**
  * Creates a canvas that draws nothing. This is useful for performance testing.

package/cpp/skia/include/utils/SkOrderedFontMgr.h

@@ -9,7 +9,19 @@
 #define SkOrderedFontMgr_DEFINED
 
 #include "include/core/SkFontMgr.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkTypes.h"
+
+#include <memory>
 #include <vector>
+
+class SkData;
+class SkFontStyle;
+class SkStreamAsset;
+class SkString;
+class SkTypeface;
+struct SkFontArguments;
+
 /**
  *  Collects an order list of other font managers, and visits them in order
  *  when a request to find or match is issued.

package/cpp/skia/include/utils/SkPaintFilterCanvas.h

@@ -8,10 +8,39 @@
 #ifndef SkPaintFilterCanvas_DEFINED
 #define SkPaintFilterCanvas_DEFINED
 
+#include "include/core/SkBlendMode.h"
+#include "include/core/SkCanvas.h"
 #include "include/core/SkCanvasVirtualEnforcer.h"
+#include "include/core/SkColor.h"
+#include "include/core/SkImageInfo.h"
+#include "include/core/SkRefCnt.h"
+#include "include/core/SkSamplingOptions.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkSize.h"
+#include "include/core/SkTypes.h"
+#include "include/private/SkTDArray.h"
 #include "include/utils/SkNWayCanvas.h"
 
-class SkAndroidFrameworkUtils;
+class GrRecordingContext;
+class SkData;
+class SkDrawable;
+class SkGlyphRunList;
+class SkImage;
+class SkMatrix;
+class SkPaint;
+class SkPath;
+class SkPicture;
+class SkPixmap;
+class SkRRect;
+class SkRegion;
+class SkSurface;
+class SkSurfaceProps;
+class SkTextBlob;
+class SkVertices;
+struct SkDrawShadowRec;
+struct SkPoint;
+struct SkRSXform;
+struct SkRect;
 
 /** \class SkPaintFilterCanvas
 

package/cpp/skia/include/utils/SkParse.h

@@ -11,6 +11,8 @@
 #define SkParse_DEFINED
 
 #include "include/core/SkColor.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 
 class SK_API SkParse {
 public:

package/cpp/skia/include/utils/SkShadowUtils.h

@@ -9,14 +9,15 @@
 #define SkShadowUtils_DEFINED
 
 #include "include/core/SkColor.h"
-#include "include/core/SkPoint3.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 #include "include/private/SkShadowFlags.h"
 
 class SkCanvas;
 class SkMatrix;
 class SkPath;
-class SkResourceCache;
+struct SkPoint3;
+struct SkRect;
 
 class SK_API SkShadowUtils {
 public:

package/cpp/skia/include/utils/SkTextUtils.h

@@ -8,11 +8,15 @@
 #ifndef SkTextUtils_DEFINED
 #define SkTextUtils_DEFINED
 
-#include "include/core/SkCanvas.h"
-#include "include/core/SkFont.h"
-#include "include/core/SkPaint.h"
-#include "include/core/SkString.h"
+#include "include/core/SkFontTypes.h"
+#include "include/core/SkScalar.h"
+#include "include/core/SkTypes.h"
 
+#include <string.h>
+
+class SkCanvas;
+class SkFont;
+class SkPaint;
 class SkPath;
 
 class SK_API SkTextUtils {

package/cpp/skia/modules/svg/include/SkSVGAttributeParser.h

@@ -71,6 +71,26 @@ public:
     }
 
 private:
+    class RestoreCurPos {
+    public:
+        explicit RestoreCurPos(SkSVGAttributeParser* self)
+            : fSelf(self), fCurPos(self->fCurPos) {}
+
+        ~RestoreCurPos() {
+            if (fSelf) {
+                fSelf->fCurPos = this->fCurPos;
+            }
+        }
+
+        void clear() { fSelf = nullptr; }
+    private:
+        SkSVGAttributeParser* fSelf;
+        const char* fCurPos;
+
+        RestoreCurPos(           const RestoreCurPos&) = delete;
+        RestoreCurPos& operator=(const RestoreCurPos&) = delete;
+    };
+
     // Stack-only
     void* operator new(size_t) = delete;
     void* operator new(size_t, void*) = delete;
@@ -82,6 +102,7 @@ private:
     bool advanceWhile(F func);
 
     bool matchStringToken(const char* token, const char** newPos = nullptr) const;
+    bool matchHexToken(const char** newPos) const;
 
     bool parseWSToken();
     bool parseEOSToken();
@@ -90,12 +111,16 @@ private:
     bool parseExpectedStringToken(const char*);
     bool parseScalarToken(SkScalar*);
     bool parseInt32Token(int32_t*);
-    bool parseHexToken(uint32_t*);
+    bool parseEscape(SkUnichar*);
+    bool parseIdentToken(SkString*);
     bool parseLengthUnitToken(SkSVGLength::Unit*);
     bool parseNamedColorToken(SkColor*);
     bool parseHexColorToken(SkColor*);
     bool parseColorComponentToken(int32_t*);
+    bool parseColorToken(SkColor*);
     bool parseRGBColorToken(SkColor*);
+    bool parseSVGColor(SkSVGColor*, SkSVGColor::Vars&&);
+    bool parseSVGColorType(SkSVGColorType*);
     bool parseFuncIRI(SkSVGFuncIRI*);
 
     // Transform helpers
@@ -127,6 +152,7 @@ private:
 
     // The current position in the input string.
     const char* fCurPos;
+    const char* fEndPos;
 
     using INHERITED = SkNoncopyable;
 };

package/cpp/skia/modules/svg/include/SkSVGDOM.h

@@ -19,6 +19,7 @@ class SkCanvas;
 class SkDOM;
 class SkStream;
 class SkSVGNode;
+struct SkSVGPresentationContext;
 class SkSVGSVG;
 
 class SkSVGDOM : public SkRefCnt {
@@ -81,6 +82,9 @@ public:
 
     void render(SkCanvas*) const;
 
+    /** Render the node with the given id as if it were the only child of the root. */
+    void renderNode(SkCanvas*, SkSVGPresentationContext&, const char* id) const;
+
 private:
     SkSVGDOM(sk_sp<SkSVGSVG>, sk_sp<SkFontMgr>, sk_sp<skresources::ResourceProvider>,
              SkSVGIDMapper&&);

package/cpp/skia/modules/svg/include/SkSVGOpenTypeSVGDecoder.h

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2022 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef SkSVGOpenTypeSVGDecoder_DEFINED
+#define SkSVGOpenTypeSVGDecoder_DEFINED
+
+#include "include/core/SkColor.h"
+#include "include/core/SkOpenTypeSVGDecoder.h"
+#include "include/core/SkSpan.h"
+#include "include/core/SkTypes.h"
+
+class SkCanvas;
+class SkSVGDOM;
+
+class SkSVGOpenTypeSVGDecoder : public SkOpenTypeSVGDecoder {
+public:
+    static std::unique_ptr<SkOpenTypeSVGDecoder> Make(const uint8_t* svg, size_t svgLength);
+    size_t approximateSize() override;
+    bool render(SkCanvas&, int upem, SkGlyphID glyphId,
+                SkColor foregroundColor, SkSpan<SkColor> palette) override;
+    ~SkSVGOpenTypeSVGDecoder() override;
+private:
+    SkSVGOpenTypeSVGDecoder(sk_sp<SkSVGDOM> skSvg, size_t approximateSize);
+    sk_sp<SkSVGDOM> fSkSvg;
+    size_t fApproximateSize;
+};
+
+#endif  // SkSVGOpenTypeSVGDecoder_DEFINED

package/cpp/skia/modules/svg/include/SkSVGRenderContext.h

@@ -15,6 +15,7 @@
 #include "include/core/SkRect.h"
 #include "include/core/SkSize.h"
 #include "include/core/SkTypes.h"
+#include "include/private/SkTHash.h"
 #include "modules/skresources/include/SkResources.h"
 #include "modules/svg/include/SkSVGAttribute.h"
 #include "modules/svg/include/SkSVGIDMapper.h"
@@ -51,6 +52,8 @@ struct SkSVGPresentationContext {
     SkSVGPresentationContext(const SkSVGPresentationContext&)            = default;
     SkSVGPresentationContext& operator=(const SkSVGPresentationContext&) = default;
 
+    const SkTHashMap<SkString, SkSVGColorType>* fNamedColors = nullptr;
+
     // Inherited presentation attributes, computed for the current node.
     SkSVGPresentationAttributes fInherited;
 };
@@ -97,9 +100,6 @@ public:
             }
         }
 
-        // Required until C++17 copy elision
-        BorrowedNode(BorrowedNode&&) = default;
-
         ~BorrowedNode() {
             if (fOwner) {
                 *fOwner = std::move(fBorrowed);

package/cpp/skia/modules/svg/include/SkSVGSVG.h

@@ -32,6 +32,8 @@ public:
 
     SkSize intrinsicSize(const SkSVGLengthContext&) const;
 
+    void renderNode(const SkSVGRenderContext&, const SkSVGIRI& iri) const;
+
 protected:
     bool onPrepareToRender(SkSVGRenderContext*) const override;
 

package/cpp/skia/modules/svg/include/SkSVGTypes.h

@@ -13,7 +13,9 @@
 #include "include/core/SkPath.h"
 #include "include/core/SkPoint.h"
 #include "include/core/SkRect.h"
+#include "include/core/SkRefCnt.h"
 #include "include/core/SkScalar.h"
+#include "include/core/SkSpan.h"
 #include "include/core/SkString.h"
 #include "include/core/SkTypes.h"
 #include "include/private/SkTDArray.h"
@@ -81,13 +83,25 @@ public:
         fValue.set(std::move(value));
     }
 
-    T* operator->() const {
+    T* operator->() {
         SkASSERT(fState == SkSVGPropertyState::kValue);
         SkASSERT(fValue.isValid());
         return fValue.get();
     }
 
-    T& operator*() const {
+    const T* operator->() const {
+        SkASSERT(fState == SkSVGPropertyState::kValue);
+        SkASSERT(fValue.isValid());
+        return fValue.get();
+    }
+
+    T& operator*() {
+        SkASSERT(fState == SkSVGPropertyState::kValue);
+        SkASSERT(fValue.isValid());
+        return *fValue;
+    }
+
+    const T& operator*() const {
         SkASSERT(fState == SkSVGPropertyState::kValue);
         SkASSERT(fValue.isValid());
         return *fValue;
@@ -166,21 +180,44 @@ public:
         kColor,
         kICCColor,
     };
+    using Vars = SkSTArray<1, SkString>;
+
+    SkSVGColor() : SkSVGColor(SK_ColorBLACK) {}
+    explicit SkSVGColor(const SkSVGColorType& c) : fType(Type::kColor), fColor(c), fVars(nullptr) {}
+    explicit SkSVGColor(Type t, Vars&& vars)
+        : fType(t), fColor(SK_ColorBLACK)
+        , fVars(vars.empty() ? nullptr : new RefCntVars(std::move(vars))) {}
+    explicit SkSVGColor(const SkSVGColorType& c, Vars&& vars)
+        : fType(Type::kColor), fColor(c)
+        , fVars(vars.empty() ? nullptr : new RefCntVars(std::move(vars))) {}
+
+    SkSVGColor(const SkSVGColor&)            = default;
+    SkSVGColor& operator=(const SkSVGColor&) = default;
+    SkSVGColor(SkSVGColor&&)                 = default;
+    SkSVGColor& operator=(SkSVGColor&&)      = default;
 
-    SkSVGColor() : fType(Type::kColor), fColor(SK_ColorBLACK) {}
-    explicit SkSVGColor(Type t) : fType(t), fColor(SK_ColorBLACK) {}
-    explicit SkSVGColor(const SkSVGColorType& c) : fType(Type::kColor), fColor(c) {}
     bool operator==(const SkSVGColor& other) const {
-        return fType == other.fType && fColor == other.fColor;
+        return fType == other.fType && fColor == other.fColor && fVars == other.fVars;
     }
     bool operator!=(const SkSVGColor& other) const { return !(*this == other); }
 
     Type type() const { return fType; }
     const SkSVGColorType& color() const { SkASSERT(fType == Type::kColor); return fColor; }
+    SkSpan<const SkString> vars() const {
+        return fVars ? SkMakeSpan<const Vars>(fVars->fData) : SkSpan<const SkString>{nullptr, 0};
+    }
+    SkSpan<      SkString> vars()       {
+        return fVars ? SkMakeSpan<      Vars>(fVars->fData) : SkSpan<      SkString>{nullptr, 0};
+    }
 
 private:
     Type fType;
     SkSVGColorType fColor;
+    struct RefCntVars : public SkNVRefCnt<RefCntVars> {
+        RefCntVars(Vars&& vars) : fData(std::move(vars)) {}
+        Vars fData;
+    };
+    sk_sp<RefCntVars> fVars;
 };
 
 class SkSVGPaint {
@@ -193,12 +230,14 @@ public:
 
     SkSVGPaint() : fType(Type::kNone), fColor(SK_ColorBLACK) {}
     explicit SkSVGPaint(Type t) : fType(t), fColor(SK_ColorBLACK) {}
-    explicit SkSVGPaint(const SkSVGColor& c) : fType(Type::kColor), fColor(c) {}
-    SkSVGPaint(const SkSVGIRI& iri, const SkSVGColor& fallback_color)
-        : fType(Type::kIRI), fColor(fallback_color), fIRI(iri) {}
+    explicit SkSVGPaint(SkSVGColor c) : fType(Type::kColor), fColor(std::move(c)) {}
+    SkSVGPaint(const SkSVGIRI& iri, SkSVGColor fallback_color)
+        : fType(Type::kIRI), fColor(std::move(fallback_color)), fIRI(iri) {}
 
     SkSVGPaint(const SkSVGPaint&)            = default;
     SkSVGPaint& operator=(const SkSVGPaint&) = default;
+    SkSVGPaint(SkSVGPaint&&)                 = default;
+    SkSVGPaint& operator=(SkSVGPaint&&)      = default;
 
     bool operator==(const SkSVGPaint& other) const {
         return fType == other.fType && fColor == other.fColor && fIRI == other.fIRI;

package/cpp/utils/RNSkLog.h

@@ -5,6 +5,8 @@
 #pragma once
 
 #include <string>
+#include <jsi/jsi.h>
+
 #ifdef ANDROID
 #include <android/log.h>
 #endif
@@ -14,6 +16,9 @@
 #endif
 
 namespace RNSkia {
+
+using namespace facebook;
+
 class RNSkLogger {
 public:
   /**
@@ -49,5 +54,27 @@ public:
 #endif
     va_end(args);
   }
+  
+  static void logToJavascriptConsole(jsi::Runtime& runtime, const std::string& message) {
+    auto console = RNSkLogger::getJavascriptConsole(runtime).asObject(runtime);
+    auto log = console.getPropertyAsFunction(runtime, "log");
+    log.call(runtime, jsi::String::createFromUtf8(runtime, message));
+  }
+  
+  static void warnToJavascriptConsole(jsi::Runtime& runtime, const std::string& message) {
+    auto console = RNSkLogger::getJavascriptConsole(runtime).asObject(runtime);
+    auto warn = console.getPropertyAsFunction(runtime, "warn");
+    warn.call(runtime, jsi::String::createFromUtf8(runtime, message));
+  }
+  
+private:
+  static jsi::Value getJavascriptConsole(jsi::Runtime& runtime) {
+    auto console = runtime.global().getProperty(runtime, "console");
+    if(console.isUndefined() || console.isNull()) {
+      jsi::detail::throwJSError(runtime, "Could not find console object.");
+      return jsi::Value::undefined();
+    }
+    return console;
+  }
 };
 } // namespace RNSkia

package/ios/RNSkia-iOS/PlatformContext.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#import "RCTBridge.h"
+#import <React/RCTBridge.h>
 
 #include <functional>
 #include <memory>

package/ios/RNSkia-iOS/RNSkDrawViewImpl.mm

@@ -3,6 +3,7 @@
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wdocumentation"
 
+#import <SkColorSpace.h>
 #import <SkSurface.h>
 #import <SkCanvas.h>