diff --git a/src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp b/src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp
index 160528c9ab2..0fa54c4da76 100644
--- a/src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp
+++ b/src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp
@@ -33,14 +33,17 @@
 #include <propertyparser.h>
 #include <rewriterview.h>
 
-#include <QDir>
 #include <QDebug>
+#include <QDir>
+#include <QVector2D>
+#include <QVector3D>
+#include <QVector4D>
 
-#include <qmljs/qmljsscopechain.h>
+#include <languageutils/fakemetaobject.h>
 #include <qmljs/parser/qmljsast_p.h>
 #include <qmljs/qmljsmodelmanagerinterface.h>
+#include <qmljs/qmljsscopechain.h>
 #include <qmljs/qmljsvalueowner.h>
-#include <languageutils/fakemetaobject.h>
 
 #include <utils/qtcassert.h>
 #include <utils/algorithm.h>
@@ -1136,7 +1139,7 @@ QVariant::Type NodeMetaInfoPrivate::variantTypeId(const PropertyName &propertyNa
     if (typeName == "vector4d")
         return QVariant::Vector4D;
 
-    return QVariant::nameToType(typeName.data());
+    return QVariant::nameToType(typeName.data()); // This is deprecated
 }
 
 int NodeMetaInfoPrivate::majorVersion() const
@@ -1849,44 +1852,91 @@ bool PropertyMetaInfo::isPointer() const
 
 QVariant PropertyMetaInfo::castedValue(const QVariant &value) const
 {
-    const QVariant variant = value;
-    QVariant copyVariant = variant;
-    if (isEnumType() || variant.canConvert<Enumeration>())
-        return variant;
+    if constexpr (!useProjectStorage()) {
+        const QVariant variant = value;
+        QVariant copyVariant = variant;
+        if (isEnumType() || variant.canConvert<Enumeration>())
+            return variant;
 
-    const TypeName &typeName = propertyTypeName();
+        const TypeName &typeName = propertyTypeName();
 
-    QVariant::Type typeId = m_nodeMetaInfoPrivateData->variantTypeId(m_propertyName);
+        QVariant::Type typeId = m_nodeMetaInfoPrivateData->variantTypeId(m_propertyName);
 
-    if (variant.type() == QVariant::UserType && variant.userType() == ModelNode::variantUserType()) {
-        return variant;
-    } else if (typeId == QVariant::UserType && typeName == "QVariant") {
-        return variant;
-    } else if (typeId == QVariant::UserType && typeName == "variant") {
-        return variant;
-    } else if (typeId == QVariant::UserType && typeName == "var") {
-        return variant;
-    } else if (variant.type() == QVariant::List) {
-        // TODO: check the contents of the list
-        return variant;
-    } else if (typeName == "var" || typeName == "variant") {
-        return variant;
-    } else if (typeName == "alias") {
-        // TODO: The QML compiler resolves the alias type. We probably should do the same.
-        return variant;
-    } else if (typeName == "<cpp>.double") {
-        return variant.toDouble();
-    } else if (typeName == "<cpp>.float") {
-        return variant.toFloat();
-    } else if (typeName == "<cpp>.int") {
-        return variant.toInt();
-    } else if (typeName == "<cpp>.bool") {
-        return variant.toBool();
-    } else if (copyVariant.convert(typeId)) {
-        return copyVariant;
+        if (variant.type() == QVariant::UserType
+            && variant.userType() == ModelNode::variantUserType()) {
+            return variant;
+        } else if (typeId == QVariant::UserType && typeName == "QVariant") {
+            return variant;
+        } else if (typeId == QVariant::UserType && typeName == "variant") {
+            return variant;
+        } else if (typeId == QVariant::UserType && typeName == "var") {
+            return variant;
+        } else if (variant.type() == QVariant::List) {
+            // TODO: check the contents of the list
+            return variant;
+        } else if (typeName == "var" || typeName == "variant") {
+            return variant;
+        } else if (typeName == "alias") {
+            // TODO: The QML compiler resolves the alias type. We probably should do the same.
+            return variant;
+        } else if (typeName == "<cpp>.double") {
+            return variant.toDouble();
+        } else if (typeName == "<cpp>.float") {
+            return variant.toFloat();
+        } else if (typeName == "<cpp>.int") {
+            return variant.toInt();
+        } else if (typeName == "<cpp>.bool") {
+            return variant.toBool();
+        } else if (copyVariant.convert(typeId)) {
+            return copyVariant;
+        }
+
+    } else {
+        if (isEnumType() || value.canConvert<Enumeration>())
+            return value;
+
+        const TypeId &typeId = propertyData().typeId;
+
+        if (value.type() == QVariant::UserType && value.userType() == ModelNode::variantUserType()) {
+            return value;
+        } else if (typeId == m_projectStorage->builtinTypeId<QVariant>()) {
+            return value;
+        } else if (value.type() == QVariant::List) {
+            // TODO: check the contents of the list
+            return value;
+        } else if (typeId == m_projectStorage->builtinTypeId<double>()) {
+            return value.toDouble();
+        } else if (typeId == m_projectStorage->builtinTypeId<float>()) {
+            return value.toFloat();
+        } else if (typeId == m_projectStorage->builtinTypeId<int>()) {
+            return value.toInt();
+        } else if (typeId == m_projectStorage->builtinTypeId<bool>()) {
+            return value.toBool();
+        } else if (typeId == m_projectStorage->builtinTypeId<QString>()) {
+            return value.toString();
+        } else if (typeId == m_projectStorage->builtinTypeId<QDateTime>()) {
+            return value.toDateTime();
+        } else if (typeId == m_projectStorage->builtinTypeId<QUrl>()) {
+            return value.toUrl();
+        } else if (typeId == m_projectStorage->builtinTypeId<QColor>()) {
+            return value.value<QColor>();
+        } else if (typeId == m_projectStorage->builtinTypeId<QVector2D>()) {
+            return value.value<QVector2D>();
+        } else if (typeId == m_projectStorage->builtinTypeId<QVector3D>()) {
+            return value.value<QVector3D>();
+        } else if (typeId == m_projectStorage->builtinTypeId<QVector4D>()) {
+            return value.value<QVector4D>();
+        } else {
+            const auto typeName = propertyTypeName();
+            const auto metaType = QMetaType::fromName(typeName);
+            auto copy = value;
+            bool converted = copy.convert(metaType);
+            if (converted)
+                return copy;
+        }
     }
 
-    return Internal::PropertyParser::variantFromString(variant.toString());
+    return Internal::PropertyParser::variantFromString(value.toString());
 }
 
 const Storage::Info::PropertyDeclaration &PropertyMetaInfo::propertyData() const
diff --git a/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h b/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h
index 06307be0f84..9ce183efe17 100644
--- a/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h
+++ b/src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h
@@ -30,13 +30,35 @@
 #include <tuple>
 #include <type_traits>
 
+QT_BEGIN_NAMESPACE
+class QColor;
+class QDateTime;
+class QString;
+class QUrl;
+class QVariant;
+class QVector2D;
+class QVector3D;
+class QVector4D;
+QT_END_NAMESPACE
+
 namespace QmlDesigner::Storage::Info {
 
 inline constexpr char QtQuick[] = "QtQuick";
 inline constexpr char QML[] = "QML";
+inline constexpr char QMLNative[] = "QML-cppnative";
 inline constexpr char Item[] = "Item";
 inline constexpr char DoubleType[] = "double";
+inline constexpr char IntType[] = "int";
+inline constexpr char BoolType[] = "bool";
+inline constexpr char FloatType[] = "float";
 inline constexpr char var[] = "var";
+inline constexpr char string[] = "string";
+inline constexpr char date[] = "date";
+inline constexpr char url[] = "url";
+inline constexpr char color[] = "color";
+inline constexpr char vector2d[] = "vector2d";
+inline constexpr char vector3d[] = "vector3d";
+inline constexpr char vector4d[] = "vector4d";
 
 template<const auto &moduleName_, const auto &typeName_>
 struct CacheType
@@ -48,7 +70,20 @@ struct CacheType
 template<typename ProjectStorage>
 class CommonTypeCache
 {
-    using CommonTypes = std::tuple<CacheType<QtQuick, Item>, CacheType<QML, DoubleType>, CacheType<QML, var>>;
+    using CommonTypes = std::tuple<CacheType<QtQuick, Item>,
+                                   CacheType<QtQuick, color>,
+                                   CacheType<QtQuick, vector2d>,
+                                   CacheType<QtQuick, vector3d>,
+                                   CacheType<QtQuick, vector4d>,
+                                   CacheType<QML, DoubleType>,
+                                   CacheType<QML, var>,
+                                   CacheType<QML, IntType>,
+                                   CacheType<QML, BoolType>,
+                                   CacheType<QML, string>,
+                                   CacheType<QML, date>,
+                                   CacheType<QML, date>,
+                                   CacheType<QML, url>,
+                                   CacheType<QMLNative, FloatType>>;
 
 public:
     CommonTypeCache(const ProjectStorage &projectStorage)
@@ -87,7 +122,29 @@ public:
     auto builtinTypeId() const
     {
         if constexpr (std::is_same_v<Type, double>)
-            return builtinTypeId<DoubleType>();
+            return typeId<QML, DoubleType>();
+        if constexpr (std::is_same_v<Type, int>)
+            return typeId<QML, IntType>();
+        if constexpr (std::is_same_v<Type, bool>)
+            return typeId<QML, BoolType>();
+        if constexpr (std::is_same_v<Type, float>)
+            return typeId<QMLNative, FloatType>();
+        if constexpr (std::is_same_v<Type, QString>)
+            return typeId<QML, string>();
+        if constexpr (std::is_same_v<Type, QDateTime>)
+            return typeId<QML, date>();
+        if constexpr (std::is_same_v<Type, QUrl>)
+            return typeId<QML, url>();
+        if constexpr (std::is_same_v<Type, QVariant>)
+            return typeId<QML, var>();
+        if constexpr (std::is_same_v<Type, QColor>)
+            return typeId<QtQuick, color>();
+        if constexpr (std::is_same_v<Type, QVector2D>)
+            return typeId<QtQuick, vector2d>();
+        if constexpr (std::is_same_v<Type, QVector3D>)
+            return typeId<QtQuick, vector3d>();
+        if constexpr (std::is_same_v<Type, QVector4D>)
+            return typeId<QtQuick, vector4d>();
         else
             return TypeId{};
     }