@nativescript/canvas 2.0.0-alpha.2 → 2.0.0-alpha.21

package/platforms/ios/src/cpp/webgl2/WebGL2RenderingContext.h

@@ -0,0 +1,227 @@
+//
+// Created by Osei Fortune on 22/03/2022.
+//
+
+#pragma once
+#pragma process_pending_includes
+
+#include <vector>
+
+#include "CanvasRenderingContext2DImpl.h"
+#include "RafImpl.h"
+#include <cmath>
+#include "Helpers.h"
+#include "WebGLRenderingContextBase.h"
+#include "WebGLRenderingContext.h"
+#include "WebGLQuery.h"
+#include "WebGLSampler.h"
+#include "WebGLSyncImpl.h"
+#include "WebGLTransformFeedback.h"
+#include "WebGLVertexArrayObject.h"
+#include "gl.h"
+
+
+class WebGL2RenderingContext : public WebGLRenderingContext {
+public:
+
+    WebGL2RenderingContext(WebGLState* state);
+
+    WebGL2RenderingContext(WebGLState* state, WebGLRenderingVersion version);
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate);
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGL2RenderingContext *renderingContext) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGL2RenderingContext::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLRenderingContextBase);
+        auto ext = v8::External::New(isolate, renderingContext);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGL2RenderingContext *GetPointer(const v8::Local<v8::Object> &object);
+
+    static void SetConstants(v8::Isolate *isolate, const v8::Local<v8::ObjectTemplate> &tmpl);
+
+    static void
+    SetProps(v8::Isolate *isolate, const v8::Local<v8::ObjectTemplate> &webgl2RenderingContextTpl);
+
+    static void SetMethods(v8::Isolate *isolate,
+                           const v8::Local<v8::ObjectTemplate> &tmpl);
+
+    static void BeginQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BeginTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindBufferBase(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindBufferRange(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BindVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void BlitFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearBufferfi(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearBufferfv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearBufferiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClearBufferuiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ClientWaitSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CompressedTexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CopyBufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CopyTexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void CreateVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DeleteVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawArraysInstanced(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawBuffers(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawElementsInstanced(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void DrawRangeElements(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void EndQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void EndTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FenceSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void FramebufferTextureLayer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniformBlockName(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniformBlockParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetActiveUniforms(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetBufferSubData(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetFragDataLocation(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetIndexedParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetInternalformatParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetQueryParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetSamplerParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetSyncParameter(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetTransformFeedbackVarying(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetUniformBlockIndex(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void GetUniformIndices(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void InvalidateFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void InvalidateSubFramebuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsQuery(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsSampler(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsSync(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void IsVertexArray(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void PauseTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ReadBuffer(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void RenderbufferStorageMultisample(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void ResumeTransformFeedback(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SamplerParameterf(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void SamplerParameteri(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexStorage2D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexStorage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TexSubImage3D(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void TransformFeedbackVaryings(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform1ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform1uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform2ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform2uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform3ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform3uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform4ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void Uniform4uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformBlockBinding(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix2x3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix2x4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix3x2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix3x4fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix4x2fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void UniformMatrix4x3fv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribDivisor(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribI4i(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribI4iv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribI4ui(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+    static void VertexAttribI4uiv(const v8::FunctionCallbackInfo<v8::Value> &args);
+
+};

package/platforms/ios/src/cpp/webgl2/WebGLQuery.h

@@ -0,0 +1,57 @@
+//
+// Created by Osei Fortune on 30/04/2022.
+//
+
+#pragma once
+
+#include "Caches.h"
+
+class WebGLQuery {
+public:
+    WebGLQuery(uint32_t query) : query_(query) {}
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLQueryTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLQuery"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLQueryTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLQuery *query) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLQuery::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLQuery);
+        auto ext = v8::External::New(isolate, query);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLQuery *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLQuery *>(ptr);
+    }
+
+    uint32_t GetQuery() {
+        return this->query_;
+    }
+
+private:
+    uint32_t query_;
+};

package/platforms/ios/src/cpp/webgl2/WebGLSampler.h

@@ -0,0 +1,60 @@
+//
+// Created by Osei Fortune on 30/04/2022.
+//
+
+#pragma once
+
+#include "Caches.h"
+#include "Common.h"
+
+
+class WebGLSampler {
+public:
+    WebGLSampler(uint32_t sampler) : sampler_(sampler) {}
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLSamplerTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLSampler"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLSamplerTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLSampler *sampler) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLSampler::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLSampler);
+        auto ext = v8::External::New(isolate, sampler);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLSampler *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLSampler *>(ptr);
+    }
+
+    uint32_t GetSampler() {
+        return this->sampler_;
+    }
+
+private:
+    uint32_t sampler_;
+};
+

package/platforms/ios/src/cpp/webgl2/WebGLSyncImpl.h

@@ -0,0 +1,57 @@
+//
+// Created by Osei Fortune on 30/04/2022.
+//
+
+#pragma once
+#include "Common.h"
+#include "Caches.h"
+
+class WebGLSyncImpl {
+public:
+    WebGLSyncImpl(WebGLSync* sync) : sync_(sync) {}
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLSyncTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLSync"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLSyncTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object> NewInstance(v8::Isolate *isolate, WebGLSyncImpl *sync) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLSyncImpl::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLSync);
+        auto ext = v8::External::New(isolate, sync);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLSyncImpl *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLSyncImpl *>(ptr);
+    }
+
+    WebGLSync * GetSync() {
+        return this->sync_;
+    }
+
+private:
+    WebGLSync* sync_;
+};

package/platforms/ios/src/cpp/webgl2/WebGLTransformFeedback.h

@@ -0,0 +1,59 @@
+//
+// Created by Osei Fortune on 30/04/2022.
+//
+
+#pragma once
+
+#include "Common.h"
+#include "Caches.h"
+
+class WebGLTransformFeedback {
+public:
+    WebGLTransformFeedback(uint32_t feedback) : feedback_(feedback) {}
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLTransformFeedbackTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLTransformFeedback"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLTransformFeedbackTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGLTransformFeedback *feedback) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLTransformFeedback::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLTransformFeedback);
+        auto ext = v8::External::New(isolate, feedback);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLTransformFeedback *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLTransformFeedback *>(ptr);
+    }
+
+    uint32_t GetFeedback() {
+        return this->feedback_;
+    }
+
+private:
+    uint32_t feedback_;
+};

package/platforms/ios/src/cpp/webgl2/WebGLVertexArrayObject.h

@@ -0,0 +1,60 @@
+//
+// Created by Osei Fortune on 30/04/2022.
+//
+
+#pragma once
+
+#include "Caches.h"
+#include "Common.h"
+#include "Helpers.h"
+
+class WebGLVertexArrayObject {
+public:
+    WebGLVertexArrayObject(uint32_t vertexArrayObject) : vertexArrayObject_(vertexArrayObject) {}
+
+    static v8::Local<v8::FunctionTemplate> GetCtor(v8::Isolate *isolate) {
+        auto cache = Caches::Get(isolate);
+        auto ctor = cache->WebGLVertexArrayObjectTmpl.get();
+        if (ctor != nullptr) {
+            return ctor->Get(isolate);
+        }
+
+        v8::Local<v8::FunctionTemplate> ctorTmpl = v8::FunctionTemplate::New(isolate);
+        ctorTmpl->InstanceTemplate()->SetInternalFieldCount(1);
+        ctorTmpl->SetClassName(ConvertToV8String(isolate, "WebGLVertexArrayObject"));
+
+        auto tmpl = ctorTmpl->InstanceTemplate();
+        tmpl->SetInternalFieldCount(1);
+
+        cache->WebGLVertexArrayObjectTmpl =
+                std::make_unique<v8::Persistent<v8::FunctionTemplate>>(isolate, ctorTmpl);
+        return ctorTmpl;
+    }
+
+    static v8::Local<v8::Object>
+    NewInstance(v8::Isolate *isolate, WebGLVertexArrayObject *vertexArrayObject) {
+        auto context = isolate->GetCurrentContext();
+        v8::EscapableHandleScope scope(isolate);
+        auto object = WebGLVertexArrayObject::GetCtor(isolate)->GetFunction(
+                context).ToLocalChecked()->NewInstance(context).ToLocalChecked();
+        SetNativeType(isolate, object, NativeType::WebGLVertexArrayObject);
+        auto ext = v8::External::New(isolate, vertexArrayObject);
+        object->SetInternalField(0, ext);
+        return scope.Escape(object);
+    }
+
+    static WebGLVertexArrayObject *GetPointer(const v8::Local<v8::Object> &object) {
+        auto ptr = object->GetInternalField(0).As<v8::External>()->Value();
+        if (ptr == nullptr) {
+            return nullptr;
+        }
+        return static_cast<WebGLVertexArrayObject *>(ptr);
+    }
+
+    uint32_t GetVertexArrayObject() {
+        return this->vertexArrayObject_;
+    }
+
+private:
+    uint32_t vertexArrayObject_;
+};

package/platforms/ios/src/module.modulemap

@@ -0,0 +1,5 @@
+module CanvasModule {
+    header "CanvasModule.h"
+    export *
+   
+}

package/Canvas2D/CanvasGradient/CanvasGradient.android.d.ts

@@ -1,10 +0,0 @@
-import { CanvasGradientBase } from './common';
-export declare class CanvasGradient extends CanvasGradientBase {
-    readonly nativeInstance: any;
-    _addColorStop: any;
-    _getMethod(name: string): any;
-    protected constructor(nativeInstance: any);
-    get native(): any;
-    static fromNative(nativeInstance: any): CanvasGradient;
-    addColorStop(offset: number, color: any): void;
-}

package/Canvas2D/CanvasGradient/CanvasGradient.android.js

@@ -1,26 +0,0 @@
-import { CanvasGradientBase } from './common';
-export class CanvasGradient extends CanvasGradientBase {
-    constructor(nativeInstance) {
-        super();
-        this.nativeInstance = nativeInstance;
-        this._getMethod('addColorStop');
-    }
-    _getMethod(name) {
-        if (this._addColorStop === undefined) {
-            const ret = this.native[name];
-            this._addColorStop = ret;
-            return ret;
-        }
-        return this._addColorStop;
-    }
-    get native() {
-        return this.nativeInstance;
-    }
-    static fromNative(nativeInstance) {
-        return new CanvasGradient(nativeInstance);
-    }
-    addColorStop(offset, color) {
-        this._addColorStop(offset, color);
-    }
-}
-//# sourceMappingURL=CanvasGradient.android.js.map

package/Canvas2D/CanvasGradient/CanvasGradient.android.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CanvasGradient.android.js","sourceRoot":"","sources":["../../../../../packages/canvas/Canvas2D/CanvasGradient/CanvasGradient.android.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE9C,MAAM,OAAO,cAAe,SAAQ,kBAAkB;IAerD,YAAsB,cAAmB;QACxC,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;QACrC,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IACjC,CAAC;IAdD,UAAU,CAAC,IAAY;QACtB,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE;YACrC,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC9B,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC;YACzB,OAAO,GAAG,CAAC;SACX;QAED,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;IAQD,IAAI,MAAM;QACT,OAAO,IAAI,CAAC,cAAc,CAAC;IAC5B,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,cAAc;QAC/B,OAAO,IAAI,cAAc,CAAC,cAAc,CAAC,CAAC;IAC3C,CAAC;IAEM,YAAY,CAAC,MAAc,EAAE,KAAU;QAC7C,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;CACD"}

package/Canvas2D/CanvasGradient/CanvasGradient.d.ts

@@ -1,12 +0,0 @@
-import {CanvasGradientBase} from './common';
-
-export declare class CanvasGradient extends CanvasGradientBase {
-    readonly nativeInstance: any;
-    readonly native: any;
-
-    protected constructor(nativeInstance: any);
-
-    static fromNative(nativeInstance: any): CanvasGradient;
-
-    addColorStop(offset: number, color: any): void;
-}

package/Canvas2D/CanvasGradient/CanvasGradient.ios.d.ts

@@ -1,8 +0,0 @@
-import { CanvasGradientBase } from './common';
-export declare class CanvasGradient extends CanvasGradientBase {
-    readonly nativeInstance: any;
-    protected constructor(nativeInstance: any);
-    get native(): any;
-    static fromNative(nativeInstance: any): CanvasGradient;
-    addColorStop(offset: number, color: string): void;
-}

package/Canvas2D/CanvasGradient/CanvasGradient.ios.js

@@ -1,19 +0,0 @@
-import { CanvasGradientBase } from './common';
-export class CanvasGradient extends CanvasGradientBase {
-    constructor(nativeInstance) {
-        super();
-        this.nativeInstance = nativeInstance;
-    }
-    get native() {
-        return this.nativeInstance;
-    }
-    static fromNative(nativeInstance) {
-        return new CanvasGradient(nativeInstance);
-    }
-    addColorStop(offset, color) {
-        if (offset >= 0.0 && offset <= 1.0) {
-            this.nativeInstance.addColorStop(offset, color);
-        }
-    }
-}
-//# sourceMappingURL=CanvasGradient.ios.js.map

package/Canvas2D/CanvasGradient/CanvasGradient.ios.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CanvasGradient.ios.js","sourceRoot":"","sources":["../../../../../packages/canvas/Canvas2D/CanvasGradient/CanvasGradient.ios.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,kBAAkB,EAAC,MAAM,UAAU,CAAC;AAE5C,MAAM,OAAO,cAAe,SAAQ,kBAAkB;IAGrD,YAAsB,cAAmB;QACxC,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACtC,CAAC;IAED,IAAI,MAAM;QACT,OAAO,IAAI,CAAC,cAAc,CAAC;IAC5B,CAAC;IAED,MAAM,CAAC,UAAU,CAAC,cAAc;QAC/B,OAAO,IAAI,cAAc,CAAC,cAAc,CAAC,CAAC;IAC3C,CAAC;IAEM,YAAY,CAAC,MAAc,EAAE,KAAa;QAChD,IAAI,MAAM,IAAI,GAAG,IAAI,MAAM,IAAI,GAAG,EAAE;YACnC,IAAI,CAAC,cAAc,CAAC,YAAY,CAC/B,MAAM,EACN,KAAK,CACL,CAAC;SACF;IACF,CAAC;CACD"}

package/Canvas2D/CanvasGradient/common.d.ts

@@ -1,3 +0,0 @@
-export declare abstract class CanvasGradientBase {
-    abstract addColorStop(offset: number, color: any): void;
-}

package/Canvas2D/CanvasGradient/common.js

@@ -1,3 +0,0 @@
-export class CanvasGradientBase {
-}
-//# sourceMappingURL=common.js.map

package/Canvas2D/CanvasGradient/common.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../../packages/canvas/Canvas2D/CanvasGradient/common.ts"],"names":[],"mappings":"AAAA,MAAM,OAAgB,kBAAkB;CAEvC"}

package/Canvas2D/CanvasPattern/CanvasPattern.android.d.ts

@@ -1,8 +0,0 @@
-import { CanvasPatternBase } from './common';
-import { DOMMatrix } from '../DOMMatrix/DOMMatrix';
-export declare class CanvasPattern extends CanvasPatternBase {
-    _setTransform: any;
-    _getMethod(name: string): any;
-    constructor(instance: any);
-    setTransform(matrix: DOMMatrix): void;
-}

package/Canvas2D/CanvasPattern/CanvasPattern.android.js

@@ -1,20 +0,0 @@
-import { CanvasPatternBase } from './common';
-export class CanvasPattern extends CanvasPatternBase {
-    constructor(instance) {
-        super(instance);
-        this.nativeInstance = instance;
-        this._getMethod('setTransform');
-    }
-    _getMethod(name) {
-        if (this._setTransform === undefined) {
-            const ret = this.native[name];
-            this._setTransform = ret;
-            return ret;
-        }
-        return this._setTransform;
-    }
-    setTransform(matrix) {
-        this._setTransform(matrix.native);
-    }
-}
-//# sourceMappingURL=CanvasPattern.android.js.map

package/Canvas2D/CanvasPattern/CanvasPattern.android.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"CanvasPattern.android.js","sourceRoot":"","sources":["../../../../../packages/canvas/Canvas2D/CanvasPattern/CanvasPattern.android.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAG7C,MAAM,OAAO,aAAc,SAAQ,iBAAiB;IAanD,YAAY,QAAa;QACxB,KAAK,CAAC,QAAQ,CAAC,CAAC;QAChB,IAAI,CAAC,cAAc,GAAG,QAAQ,CAAC;QAC/B,IAAI,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;IACjC,CAAC;IAdD,UAAU,CAAC,IAAY;QACtB,IAAI,IAAI,CAAC,aAAa,KAAK,SAAS,EAAE;YACrC,MAAM,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;YAC9B,IAAI,CAAC,aAAa,GAAG,GAAG,CAAC;YACzB,OAAO,GAAG,CAAC;SACX;QAED,OAAO,IAAI,CAAC,aAAa,CAAC;IAC3B,CAAC;IAQM,YAAY,CAAC,MAAiB;QACpC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACnC,CAAC;CACD"}