@cervisebas/nodegui-plugin-animation 1.0.0

package/dist/lib/types/PropertyNames.d.ts

@@ -0,0 +1 @@
+export type PropertyName = 'geometry' | 'pos' | 'size' | 'minimumSize' | 'maximumSize' | 'windowOpacity' | 'visible';

package/dist/lib/types/PropertyNames.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/utils/addon.d.ts

@@ -0,0 +1,2 @@
+declare const addon: any;
+export default addon;

package/dist/lib/utils/addon.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const addon = require('../../../build/Release/nodegui_plugin_animation.node');
+exports.default = addon;

package/package.json

@@ -0,0 +1,60 @@
+{
+    "name": "@cervisebas/nodegui-plugin-animation",
+    "version": "1.0.0",
+    "main": "dist/index.js",
+    "typings": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc && npm run build:addon",
+        "postinstall": "npm run build:addon",
+        "build:addon": "cross-env CMAKE_BUILD_PARALLEL_LEVEL=8 cmake-js compile",
+        "dev": "tsc && qode dist/demo.js",
+        "test": "qode ./node_modules/.bin/jest",
+        "lint:cpp": "clang-format -i --glob=src/cpp/**/*.[h,c,cpp]*",
+        "lint:ts": "tsc --noEmit && eslint './src/**/*.{ts,tsx,js,jsx}' --fix"
+    },
+    "author": "Cervisebas",
+    "license": "MIT",
+    "peerDependencies": {
+        "@nodegui/nodegui": "^0.71.0"
+    },
+    "files": [
+        "config",
+        "dist",
+        "src",
+        ".clang-format",
+        "CMakeLists.txt",
+        "package.json",
+        "README.md"
+    ],
+    "dependencies": {
+        "bluebird": "^3.7.2",
+        "cmake-js": "^7.4.0",
+        "cross-env": "^10.1.0",
+        "node-addon-api": "^8.5.0"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.39.2",
+        "@nodegui/nodegui": "^0.73.0",
+        "@types/jest": "^30.0.0",
+        "@types/node": "^25.0.6",
+        "@typescript-eslint/eslint-plugin": "~8.52.0",
+        "@typescript-eslint/parser": "~8.52.0",
+        "clang-format": "~1.8.0",
+        "eslint": "^9.39.2",
+        "eslint-config-prettier": "~10.1.8",
+        "eslint-plugin-prettier": "~5.5.4",
+        "globals": "^17.0.0",
+        "husky": "^9.1.7",
+        "jest": "~30.2.0",
+        "jiti": "^2.6.1",
+        "prettier": "^3.7.4",
+        "ts-jest": "~29.4.6",
+        "typescript": "~5.9.3",
+        "typescript-eslint": "^8.52.0"
+    },
+    "husky": {
+        "hooks": {
+            "pre-push": "npm run lint:ts && npm run lint:cpp && npm run test"
+        }
+    }
+}

package/src/cpp/QAbstractAnimation/qabstractanimation_macro.h

@@ -0,0 +1,150 @@
+
+#pragma once
+#include <nodegui/QtCore/QObject/qobject_macro.h>
+
+#include <QAbstractAnimation>
+
+/*
+
+    This macro adds common QAbstractAnimation macro exported methods
+    The exported methods are taken into this macro to avoid writing them in each
+   and every time we export.
+ */
+
+#ifndef QABSTRACTANIMATION_WRAPPED_METHODS_DECLARATION
+#define QABSTRACTANIMATION_WRAPPED_METHODS_DECLARATION                       \
+  QOBJECT_WRAPPED_METHODS_DECLARATION                                        \
+                                                                             \
+  Napi::Value start(const Napi::CallbackInfo& info) {                        \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    if (info.Length() == 1) {                                                \
+      Napi::Number deletionPolicy = info[0].As<Napi::Number>();              \
+      this->instance->start(static_cast<QAbstractAnimation::DeletionPolicy>( \
+          deletionPolicy.Int32Value()));                                     \
+    } else {                                                                 \
+      this->instance->start();                                               \
+    }                                                                        \
+    return env.Null();                                                       \
+  }                                                                          \
+  Napi::Value stop(const Napi::CallbackInfo& info) {                         \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    this->instance->stop();                                                  \
+    return env.Null();                                                       \
+  }                                                                          \
+  Napi::Value currentLoop(const Napi::CallbackInfo& info) {                  \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    int loop = this->instance->currentLoop();                                \
+    return Napi::Value::From(env, loop);                                     \
+  }                                                                          \
+  Napi::Value currentLoopTime(const Napi::CallbackInfo& info) {              \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    int time = this->instance->currentLoopTime();                            \
+    return Napi::Value::From(env, time);                                     \
+  }                                                                          \
+  Napi::Value currentTime(const Napi::CallbackInfo& info) {                  \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    int time = this->instance->currentTime();                                \
+    return Napi::Value::From(env, time);                                     \
+  }                                                                          \
+  Napi::Value direction(const Napi::CallbackInfo& info) {                    \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    int value = static_cast<int>(this->instance->direction());               \
+    return Napi::Value::From(env, value);                                    \
+  }                                                                          \
+  Napi::Value duration(const Napi::CallbackInfo& info) {                     \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    int duration = this->instance->duration();                               \
+    return Napi::Value::From(env, duration);                                 \
+  }                                                                          \
+  Napi::Value loopCount(const Napi::CallbackInfo& info) {                    \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    int loopCount = this->instance->loopCount();                             \
+    return Napi::Value::From(env, loopCount);                                \
+  }                                                                          \
+  Napi::Value setDirection(const Napi::CallbackInfo& info) {                 \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    Napi::Number directionValue = info[0].As<Napi::Number>();                \
+    int direction = directionValue.Int32Value();                             \
+                                                                             \
+    this->instance->setDirection(                                            \
+        static_cast<QAbstractAnimation::Direction>(direction));              \
+    return env.Null();                                                       \
+  }                                                                          \
+  Napi::Value setLoopCount(const Napi::CallbackInfo& info) {                 \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    Napi::Number loopCount = info[0].As<Napi::Number>();                     \
+    this->instance->setLoopCount(loopCount.Int32Value());                    \
+    return env.Null();                                                       \
+  }                                                                          \
+  Napi::Value state(const Napi::CallbackInfo& info) {                        \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    int value = static_cast<int>(this->instance->state());                   \
+    return Napi::Value::From(env, value);                                    \
+  }                                                                          \
+  Napi::Value totalDuration(const Napi::CallbackInfo& info) {                \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    int value = this->instance->totalDuration();                             \
+    return Napi::Value::From(env, value);                                    \
+  }                                                                          \
+  Napi::Value pause(const Napi::CallbackInfo& info) {                        \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    this->instance->pause();                                                 \
+    return env.Null();                                                       \
+  }                                                                          \
+  Napi::Value resume(const Napi::CallbackInfo& info) {                       \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    this->instance->resume();                                                \
+    return env.Null();                                                       \
+  }                                                                          \
+  Napi::Value setCurrentTime(const Napi::CallbackInfo& info) {               \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    Napi::Number time = info[0].As<Napi::Number>();                          \
+    this->instance->setCurrentTime(time.Int32Value());                       \
+    return env.Null();                                                       \
+  }                                                                          \
+  Napi::Value setPaused(const Napi::CallbackInfo& info) {                    \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    Napi::Boolean value = info[0].As<Napi::Boolean>();                       \
+    this->instance->setPaused(value.Value());                                \
+    return env.Null();                                                       \
+  }
+#endif
+
+#ifndef QABSTRACTANIMATION_WRAPPED_METHODS_EXPORT_DEFINE
+#define QABSTRACTANIMATION_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName)   \
+                                                                              \
+  QOBJECT_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName)                    \
+  InstanceMethod("start", &ComponentWrapName::start),                         \
+      InstanceMethod("stop", &ComponentWrapName::stop),                       \
+      InstanceMethod("currentLoop", &ComponentWrapName::currentLoop),         \
+      InstanceMethod("currentLoopTime", &ComponentWrapName::currentLoopTime), \
+      InstanceMethod("currentTime", &ComponentWrapName::currentTime),         \
+      InstanceMethod("direction", &ComponentWrapName::direction),             \
+      InstanceMethod("duration", &ComponentWrapName::duration),               \
+      InstanceMethod("loopCount", &ComponentWrapName::loopCount),             \
+      InstanceMethod("setDirection", &ComponentWrapName::setDirection),       \
+      InstanceMethod("setLoopCount", &ComponentWrapName::setLoopCount),       \
+      InstanceMethod("state", &ComponentWrapName::state),                     \
+      InstanceMethod("totalDuration", &ComponentWrapName::totalDuration),     \
+      InstanceMethod("pause", &ComponentWrapName::pause),                     \
+      InstanceMethod("resume", &ComponentWrapName::resume),                   \
+      InstanceMethod("setCurrentTime", &ComponentWrapName::setCurrentTime),   \
+      InstanceMethod("setPaused", &ComponentWrapName::setPaused),
+
+#endif

package/src/cpp/QPropertyAnimation/npropertyanimation.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <nodegui/core/Events/eventwidget.h>
+#include <nodegui/core/Events/eventwidget_macro.h>
+
+#include <QPropertyAnimation>
+
+class NPropertyAnimation : public QPropertyAnimation, public EventWidget {
+  Q_OBJECT
+  EVENTWIDGET_IMPLEMENTATIONS(QPropertyAnimation)
+ public:
+  using QPropertyAnimation::QPropertyAnimation;
+};

package/src/cpp/QPropertyAnimation/qpropertyanimation_wrap.cpp

@@ -0,0 +1,82 @@
+#include "qpropertyanimation_wrap.h"
+
+#include <nodegui/Extras/Utils/nutils.h>
+#include <nodegui/QtCore/QObject/qobject_wrap.h>
+
+#include <QString>
+
+Napi::FunctionReference QPropertyAnimationWrap::constructor;
+
+Napi::Object QPropertyAnimationWrap::init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+  char CLASSNAME[] = "QPropertyAnimation";
+  Napi::Function func = DefineClass(
+      env, CLASSNAME,
+      {InstanceMethod("setPropertyName",
+                      &QPropertyAnimationWrap::setPropertyName),
+       InstanceMethod("setTargetObject",
+                      &QPropertyAnimationWrap::setTargetObject),
+       InstanceMethod("propertyName", &QPropertyAnimationWrap::propertyName),
+       QVARIANTANIMATION_WRAPPED_METHODS_EXPORT_DEFINE(
+           QPropertyAnimationWrap)});
+  constructor = Napi::Persistent(func);
+  exports.Set(CLASSNAME, func);
+  return exports;
+}
+
+NPropertyAnimation *QPropertyAnimationWrap::getInternalInstance() {
+  return this->instance;
+}
+
+QPropertyAnimationWrap::QPropertyAnimationWrap(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<QPropertyAnimationWrap>(info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  if (info.Length() == 1) {
+    Napi::Object parentObject = info[0].As<Napi::Object>();
+    QObjectWrap *parentObjectWrap =
+        Napi::ObjectWrap<QObjectWrap>::Unwrap(parentObject);
+    this->instance =
+        new NPropertyAnimation(parentObjectWrap->getInternalInstance());
+  } else if (info.Length() == 0) {
+    this->instance = new NPropertyAnimation();
+  } else {
+    Napi::TypeError::New(env, "Wrong number of arguments")
+        .ThrowAsJavaScriptException();
+  }
+}
+
+QPropertyAnimationWrap::~QPropertyAnimationWrap() {
+  extrautils::safeDelete(this->instance);
+}
+
+Napi::Value QPropertyAnimationWrap::setPropertyName(
+    const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  Napi::String name = info[0].As<Napi::String>();
+  std::string nameString = name.Utf8Value();
+  QByteArray byteArray(nameString.c_str(), nameString.length());
+  this->instance->setPropertyName(byteArray);
+  return env.Null();
+}
+Napi::Value QPropertyAnimationWrap::propertyName(
+    const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+  QString name = this->instance->propertyName();
+  return Napi::String::From(env, name.toStdString());
+}
+Napi::Value QPropertyAnimationWrap::setTargetObject(
+    const Napi::CallbackInfo &info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  Napi::Object qobjectWrapObject = info[0].As<Napi::Object>();
+  QObjectWrap *objectWrap =
+      Napi::ObjectWrap<QObjectWrap>::Unwrap(qobjectWrapObject);
+  this->instance->setTargetObject(objectWrap->getInternalInstance());
+
+  return env.Null();
+}

package/src/cpp/QPropertyAnimation/qpropertyanimation_wrap.h

@@ -0,0 +1,26 @@
+#pragma once
+#include <napi.h>
+#include <stdlib.h>
+
+#include <QPointer>
+
+#include "QVariantAnimation/qvariantanimation_macro.h"
+#include "npropertyanimation.hpp"
+
+class QPropertyAnimationWrap : public Napi::ObjectWrap<QPropertyAnimationWrap> {
+ private:
+  QPointer<NPropertyAnimation> instance;
+
+ public:
+  static Napi::Object init(Napi::Env env, Napi::Object exports);
+  QPropertyAnimationWrap(const Napi::CallbackInfo &info);
+  ~QPropertyAnimationWrap();
+  NPropertyAnimation *getInternalInstance();
+  static Napi::FunctionReference constructor;
+  // wrapped methods
+  Napi::Value setPropertyName(const Napi::CallbackInfo &info);
+  Napi::Value propertyName(const Napi::CallbackInfo &info);
+  Napi::Value setTargetObject(const Napi::CallbackInfo &info);
+
+  QVARIANTANIMATION_WRAPPED_METHODS_DECLARATION
+};

package/src/cpp/QVariantAnimation/nvariantanimation.hpp

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <nodegui/core/Events/eventwidget.h>
+#include <nodegui/core/Events/eventwidget_macro.h>
+
+#include <QVariantAnimation>
+
+class NVariantAnimation : public QVariantAnimation, public EventWidget {
+  Q_OBJECT
+  EVENTWIDGET_IMPLEMENTATIONS(QVariantAnimation)
+ public:
+  using QVariantAnimation::QVariantAnimation;
+};

package/src/cpp/QVariantAnimation/qvariantanimation_macro.h

@@ -0,0 +1,66 @@
+
+#pragma once
+#include <nodegui/Extras/Utils/nutils.h>
+
+#include "QAbstractAnimation/qabstractanimation_macro.h"
+/*
+
+    This macro adds common QVariantAnimation macro exported methods
+    The exported methods are taken into this macro to avoid writing them in each
+   and every time we export.
+ */
+
+#ifndef QVARIANTANIMATION_WRAPPED_METHODS_DECLARATION
+#define QVARIANTANIMATION_WRAPPED_METHODS_DECLARATION                        \
+  QABSTRACTANIMATION_WRAPPED_METHODS_DECLARATION                             \
+                                                                             \
+  Napi::Value setDuration(const Napi::CallbackInfo &info) {                  \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    Napi::Number duration = info[0].As<Napi::Number>();                      \
+    this->instance->setDuration(duration.Int32Value());                      \
+    return env.Null();                                                       \
+  }                                                                          \
+                                                                             \
+  Napi::Value setStartValue(const Napi::CallbackInfo &info) {                \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    Napi::Value value = info[0];                                             \
+    auto variant =                                                           \
+        QSharedPointer<QVariant>(extrautils::convertToQVariant(env, value)); \
+    this->instance->setStartValue(*variant);                                 \
+    return env.Null();                                                       \
+  }                                                                          \
+                                                                             \
+  Napi::Value setEndValue(const Napi::CallbackInfo &info) {                  \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    Napi::Value value = info[0];                                             \
+    auto variant =                                                           \
+        QSharedPointer<QVariant>(extrautils::convertToQVariant(env, value)); \
+    this->instance->setEndValue(*variant);                                   \
+    return env.Null();                                                       \
+  }                                                                          \
+  Napi::Value setKeyValueAt(const Napi::CallbackInfo &info) {                \
+    Napi::Env env = info.Env();                                              \
+    Napi::HandleScope scope(env);                                            \
+    Napi::Number step = info[0].As<Napi::Number>();                          \
+    Napi::Value value = info[1];                                             \
+    auto variant =                                                           \
+        QSharedPointer<QVariant>(extrautils::convertToQVariant(env, value)); \
+    this->instance->setKeyValueAt(step.DoubleValue(), *variant);             \
+    return env.Null();                                                       \
+  }
+
+#endif
+
+#ifndef QVARIANTANIMATION_WRAPPED_METHODS_EXPORT_DEFINE
+#define QVARIANTANIMATION_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName) \
+                                                                           \
+  QABSTRACTANIMATION_WRAPPED_METHODS_EXPORT_DEFINE(ComponentWrapName)      \
+  InstanceMethod("setDuration", &ComponentWrapName::setDuration),          \
+      InstanceMethod("setStartValue", &ComponentWrapName::setStartValue),  \
+      InstanceMethod("setEndValue", &ComponentWrapName::setEndValue),      \
+      InstanceMethod("setKeyValueAt", &ComponentWrapName::setKeyValueAt),
+
+#endif

package/src/cpp/QVariantAnimation/qvariantanimation_wrap.cpp

@@ -0,0 +1,47 @@
+#include "qvariantanimation_wrap.h"
+
+#include <nodegui/Extras/Utils/nutils.h>
+#include <nodegui/QtCore/QObject/qobject_wrap.h>
+
+#include <QSharedPointer>
+#include <QString>
+
+Napi::FunctionReference QVariantAnimationWrap::constructor;
+
+Napi::Object QVariantAnimationWrap::init(Napi::Env env, Napi::Object exports) {
+  Napi::HandleScope scope(env);
+  char CLASSNAME[] = "QVariantAnimation";
+  Napi::Function func = DefineClass(
+      env, CLASSNAME,
+      {QVARIANTANIMATION_WRAPPED_METHODS_EXPORT_DEFINE(QVariantAnimationWrap)});
+  constructor = Napi::Persistent(func);
+  exports.Set(CLASSNAME, func);
+  return exports;
+}
+
+NVariantAnimation *QVariantAnimationWrap::getInternalInstance() {
+  return this->instance;
+}
+
+QVariantAnimationWrap::QVariantAnimationWrap(const Napi::CallbackInfo &info)
+    : Napi::ObjectWrap<QVariantAnimationWrap>(info) {
+  Napi::Env env = info.Env();
+  Napi::HandleScope scope(env);
+
+  if (info.Length() == 1) {
+    Napi::Object parentObject = info[0].As<Napi::Object>();
+    QObjectWrap *parentObjectWrap =
+        Napi::ObjectWrap<QObjectWrap>::Unwrap(parentObject);
+    this->instance =
+        new NVariantAnimation(parentObjectWrap->getInternalInstance());
+  } else if (info.Length() == 0) {
+    this->instance = new NVariantAnimation();
+  } else {
+    Napi::TypeError::New(env, "Wrong number of arguments")
+        .ThrowAsJavaScriptException();
+  }
+}
+
+QVariantAnimationWrap::~QVariantAnimationWrap() {
+  extrautils::safeDelete(this->instance);
+}

package/src/cpp/QVariantAnimation/qvariantanimation_wrap.h

@@ -0,0 +1,21 @@
+#pragma once
+#include <napi.h>
+#include <stdlib.h>
+
+#include <QPointer>
+
+#include "nvariantanimation.hpp"
+#include "qvariantanimation_macro.h"
+
+class QVariantAnimationWrap : public Napi::ObjectWrap<QVariantAnimationWrap> {
+ private:
+  QPointer<NVariantAnimation> instance;
+
+ public:
+  static Napi::Object init(Napi::Env env, Napi::Object exports);
+  QVariantAnimationWrap(const Napi::CallbackInfo &info);
+  ~QVariantAnimationWrap();
+  NVariantAnimation *getInternalInstance();
+  static Napi::FunctionReference constructor;
+  QVARIANTANIMATION_WRAPPED_METHODS_DECLARATION
+};

package/src/cpp/main.cpp

@@ -0,0 +1,12 @@
+#include <napi.h>
+
+#include "QPropertyAnimation/qpropertyanimation_wrap.h"
+#include "QVariantAnimation/qvariantanimation_wrap.h"
+
+Napi::Object Main(Napi::Env env, Napi::Object exports) {
+  QPropertyAnimationWrap::init(env, exports);
+  QVariantAnimationWrap::init(env, exports);
+  return exports;
+}
+
+NODE_API_MODULE(NODE_GYP_MODULE_NAME, Main)

package/src/demo.ts

@@ -0,0 +1,23 @@
+import { QPropertyAnimation } from './index';
+import { QPushButton } from '@nodegui/nodegui';
+
+const animation = new QPropertyAnimation();
+
+const button = new QPushButton();
+button.setText('Animated Button');
+button.show();
+
+animation.setPropertyName('windowOpacity');
+animation.setTargetObject(button);
+
+animation.setDuration(5000);
+animation.setStartValue(0.4);
+animation.setKeyValueAt(0.5, 1.0);
+animation.setEndValue(1.0);
+
+animation.start();
+
+Object.assign(global, {
+  button: button,
+  animation: animation,
+});

package/src/index.ts

@@ -0,0 +1,4 @@
+export { DeletionPolicy, Direction, State, QAbstractAnimation } from './lib/QAbstractAnimation';
+export { NodeVariantAnimation, QVariantAnimation, QVariantAnimationEvents } from './lib/QVariantAnimation';
+export { QPropertyAnimation, QPropertyAnimationEvents } from './lib/QPropertyAnimation';
+export { PropertyName } from './lib/types/PropertyNames';

package/src/lib/QAbstractAnimation.ts

@@ -0,0 +1,57 @@
+import { QObject, QObjectSignals } from '@nodegui/nodegui';
+export abstract class QAbstractAnimation extends QObject<QObjectSignals> {
+    start(policy?: DeletionPolicy): void {
+        if (policy) {
+            this.native?.start(policy);
+        } else {
+            this.native?.start();
+        }
+    }
+    stop(): void {
+        this.native?.stop();
+    }
+    currentLoop(): number {
+        return this.native?.currentLoop();
+    }
+    currentLoopTime(): number {
+        return this.native?.currentLoopTime();
+    }
+    currentTime(): number {
+        return this.native?.currentTime();
+    }
+    direction(): Direction {
+        return this.native?.direction();
+    }
+    duration(): number {
+        return this.native?.duration();
+    }
+    loopCount(): number {
+        return this.native?.loopCount();
+    }
+    setDirection(direction: Direction): void {
+        return this.native?.setDirection(direction);
+    }
+    setLoopCount(loopCount: number): void {
+        return this.native?.setLoopCount(loopCount);
+    }
+    state(): State {
+        return this.native?.state();
+    }
+    totalDuration(): number {
+        return this.native?.totalDuration();
+    }
+}
+
+export enum DeletionPolicy {
+    KeepWhenStopped = 0,
+    DeleteWhenStopped = 1,
+}
+export enum Direction {
+    Forward = 0,
+    Backward = 1,
+}
+export enum State {
+    Stopped = 0,
+    Paused = 1,
+    Running = 2,
+}

package/src/lib/QPropertyAnimation.ts

@@ -0,0 +1,36 @@
+import { NativeElement, QObject } from '@nodegui/nodegui';
+import addon from './utils/addon';
+import { NodeVariantAnimation, QVariantAnimationEvents } from './QVariantAnimation';
+import { PropertyName } from './types/PropertyNames';
+
+export const QPropertyAnimationEvents = Object.freeze({
+    ...QVariantAnimationEvents,
+});
+export class QPropertyAnimation extends NodeVariantAnimation {
+    public native: NativeElement;
+    public nodeParent?: QObject<never>;
+
+    constructor(parent?: QObject<never>) {
+        let native;
+        if (parent) {
+            native = new addon.QPropertyAnimation(parent.native);
+        } else {
+            native = new addon.QPropertyAnimation();
+        }
+        super(native);
+        this.native = native;
+        this.nodeParent = parent;
+    }
+
+    setPropertyName(name: PropertyName): void {
+        this.native.setPropertyName(name);
+    }
+
+    propertyName(): PropertyName {
+        return this.native.propertyName();
+    }
+
+    setTargetObject(object: QObject<never>): void {
+        return this.native.setTargetObject(object.native);
+    }
+}