QmlDesigner: Deprecate optionally old node meta info API

If the project storage is activated the old API will be deprecated.
Hepefully people now stop to use the old API. You can still use it but
you have to write an implementation for the new one too.

Task-number: QDS-12102
Change-Id: Iac23da1648ff44e27a2ee7840e0d3eeb1fb8caf9
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Qt CI Patch Build Bot <ci_patchbuild_bot@qt.io>

src/plugins/qmldesigner/components/assetslibrary/assetslibrarywidget.cpp

@@ -273,8 +273,11 @@ void AssetsLibraryWidget::setHasSceneEnv(bool b)
     emit hasSceneEnvChanged();
 }
 
-void AssetsLibraryWidget::handleDeleteEffects(const QStringList &effectNames)
+void AssetsLibraryWidget::handleDeleteEffects([[maybe_unused]] const QStringList &effectNames)
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+// That code has to rewritten with modules. Seem try to find all effects nodes.
+#else
     DesignDocument *document = QmlDesignerPlugin::instance()->currentDesignDocument();
     if (!document)
         return;
@@ -340,6 +343,7 @@ void AssetsLibraryWidget::handleDeleteEffects(const QStringList &effectNames)
         document->clearUndoRedoStacks();
 
     m_assetsView->emitCustomNotification("effectcomposer_effects_deleted", {}, {effectNames});
+#endif
 }
 
 void AssetsLibraryWidget::invalidateThumbnail(const QString &id)

src/plugins/qmldesigner/components/bindingeditor/actioneditor.cpp

@@ -229,6 +229,7 @@ void ActionEditor::prepareConnections()
     QList<ActionEditorDialog::SingletonOption> singletons;
     QStringList states;
 
+    [[maybe_unused]] auto model = m_modelNode.model();
     const QList<QmlDesigner::ModelNode> allNodes = m_modelNode.view()->allModelNodes();
     for (const auto &modelNode : allNodes) {
         // Skip nodes without specified id
@@ -240,11 +241,19 @@ void ActionEditor::prepareConnections()
         for (const auto &property : modelNode.metaInfo().properties()) {
             if (isSkippedType(property.propertyType()))
                 continue;
-
+#ifdef QDS_USE_PROJECTSTORAGE
+            auto exportedTypeName = model->exportedTypeNameForMetaInfo(property.propertyType())
+                                        .name.toQByteArray();
+            connection.properties.append(
+                ActionEditorDialog::PropertyOption(QString::fromUtf8(property.name()),
+                                                   exportedTypeName,
+                                                   property.isWritable()));
+#else
             connection.properties.append(
                 ActionEditorDialog::PropertyOption(QString::fromUtf8(property.name()),
                                                    skipCpp(property.propertyType().typeName()),
                                                    property.isWritable()));
+#endif
         }
 
         for (const VariantProperty &variantProperty : modelNode.variantProperties()) {
@@ -305,11 +314,21 @@ void ActionEditor::prepareConnections()
                     for (const auto &property : metaInfo.properties()) {
                         if (isSkippedType(property.propertyType()))
                             continue;
-
+#ifdef QDS_USE_PROJECTSTORAGE
+                        auto exportedTypeName = model
+                                                    ->exportedTypeNameForMetaInfo(
+                                                        property.propertyType())
+                                                    .name.toQByteArray();
+                        singelton.properties.append(
+                            ActionEditorDialog::PropertyOption(QString::fromUtf8(property.name()),
+                                                               exportedTypeName,
+                                                               property.isWritable()));
+#else
                         singelton.properties.append(ActionEditorDialog::PropertyOption(
                             QString::fromUtf8(property.name()),
                             skipCpp(property.propertyType().typeName()),
                             property.isWritable()));
+#endif
                     }
 
                     if (!singelton.properties.isEmpty()) {

src/plugins/qmldesigner/components/bindingeditor/bindingeditor.cpp

@@ -176,22 +176,22 @@ bool isType(const TypeName &first, const TypeName &second, const Tuple &...types
 
 bool compareTypes(const NodeMetaInfo &sourceType, const NodeMetaInfo &targetType)
 {
-    if constexpr (useProjectStorage()) {
+#ifdef QDS_USE_PROJECTSTORAGE
-        return targetType.isVariant() || sourceType.isVariant() || targetType == sourceType
+    return targetType.isVariant() || sourceType.isVariant() || targetType == sourceType
-               || (targetType.isNumber() && sourceType.isNumber())
+           || (targetType.isNumber() && sourceType.isNumber())
-               || (targetType.isColor() && sourceType.isColor())
+           || (targetType.isColor() && sourceType.isColor())
-               || (targetType.isString() && sourceType.isString());
+           || (targetType.isString() && sourceType.isString());
-    } else {
+#else
-        const TypeName source = sourceType.simplifiedTypeName();
+    const TypeName source = sourceType.simplifiedTypeName();
-        const TypeName target = targetType.simplifiedTypeName();
+    const TypeName target = targetType.simplifiedTypeName();
 
-        static constexpr auto variantTypes = std::make_tuple("alias", "unknown", "variant", "var");
+    static constexpr auto variantTypes = std::make_tuple("alias", "unknown", "variant", "var");
 
-        return isType(variantTypes, target) || isType(variantTypes, source) || target == source
+    return isType(variantTypes, target) || isType(variantTypes, source) || target == source
-               || targetType == sourceType || isType(target, source, "double", "real", "int")
+           || targetType == sourceType || isType(target, source, "double", "real", "int")
-               || isType(target, source, "QColor", "color")
+           || isType(target, source, "QColor", "color")
-               || isType(target, source, "QString", "string");
+           || isType(target, source, "QString", "string");
-    }
+#endif
 }
 } // namespace
 
@@ -287,8 +287,13 @@ void BindingEditor::updateWindowName()
                                + exportedTypeNames.front().name.toQString() + "]";
             }
         } else {
+#ifdef QDS_USE_PROJECTSTORAGE
+            targetString = " [" + (m_targetName.isEmpty() ? QString() : (m_targetName + ": "))
+                           + QString::fromUtf8(m_backendValueType.displayName()) + "]";
+#else
             targetString = " [" + (m_targetName.isEmpty() ? QString() : (m_targetName + ": "))
                            + QString::fromUtf8(m_backendValueType.simplifiedTypeName()) + "]";
+#endif
         }
 
         m_dialog->setWindowTitle(m_dialog->defaultTitle() + targetString);

src/plugins/qmldesigner/components/bindingeditor/signallist.cpp

@@ -218,14 +218,18 @@ void SignalList::addConnection(const QModelIndex &modelIndex)
     const ModelNode rootModelNode = view->rootModelNode();
 
     if (rootModelNode.isValid() && rootModelNode.metaInfo().isValid()) {
-        NodeMetaInfo nodeMetaInfo = view->model()->qtQuickConnectionsMetaInfo();
+#ifndef QDS_USE_PROJECTSTORAGE
+        NodeMetaInfo nodeMetaInfo = view->model()->qtQmlConnectionsMetaInfo();
         if (nodeMetaInfo.isValid()) {
-            view->executeInTransaction("ConnectionModel::addConnection",
+#endif
-                                       [this, view, nodeMetaInfo, targetModelIndex, modelIndex,
+            view->executeInTransaction("ConnectionModel::addConnection", [&] {
-                                        buttonModelIndex, signalName, &rootModelNode] {
+#ifdef QDS_USE_PROJECTSTORAGE
+                ModelNode newNode = view->createModelNode("Connections");
+#else
                 ModelNode newNode = view->createModelNode("QtQuick.Connections",
                                                           nodeMetaInfo.majorVersion(),
                                                           nodeMetaInfo.minorVersion());
+#endif
                 const QString source = m_modelNode.validId() + ".trigger()";
 
                 if (QmlItemNode::isValidQmlItemNode(m_modelNode))
@@ -240,7 +244,9 @@ void SignalList::addConnection(const QModelIndex &modelIndex)
                 m_model->setConnected(modelIndex.row(), true);
                 m_model->setData(buttonModelIndex, newNode.internalId(), SignalListModel::ConnectionsInternalIdRole);
             });
+#ifndef QDS_USE_PROJECTSTORAGE
         }
+#endif
     }
 }
 

src/plugins/qmldesigner/components/collectioneditor/collectionview.cpp

@@ -29,10 +29,9 @@
 
 namespace {
 
-inline bool isStudioCollectionModel(const QmlDesigner::ModelNode &node)
+bool isStudioCollectionModel(const QmlDesigner::ModelNode &node)
 {
-    using namespace QmlDesigner::CollectionEditorConstants;
+    return node.metaInfo().isQtQuickStudioUtilsJsonListModel();
-    return node.metaInfo().typeName() == JSONCOLLECTIONMODEL_TYPENAME;
 }
 
 inline void setVariantPropertyValue(const QmlDesigner::ModelNode &node,
@@ -201,11 +200,14 @@ void CollectionView::addResource(const QUrl &url, const QString &name)
         } else {
             sourceAddress = url.toString();
         }
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        ModelNode resourceNode = createModelNode("JsonListModel");
+#else
         const NodeMetaInfo resourceMetaInfo = jsonCollectionMetaInfo();
         ModelNode resourceNode = createModelNode(resourceMetaInfo.typeName(),
                                                  resourceMetaInfo.majorVersion(),
                                                  resourceMetaInfo.minorVersion());
+#endif
         VariantProperty sourceProperty = resourceNode.variantProperty(
             CollectionEditorConstants::SOURCEFILE_PROPERTY);
         VariantProperty nameProperty = resourceNode.variantProperty("objectName");

src/plugins/qmldesigner/components/componentcore/designeractionmanager.cpp

@@ -579,10 +579,14 @@ QList<SlotList> getSlotsLists(const ModelNode &node)
 //creates connection without signalHandlerProperty
 ModelNode createNewConnection(ModelNode targetNode)
 {
-    NodeMetaInfo connectionsMetaInfo = targetNode.view()->model()->qtQuickConnectionsMetaInfo();
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode newConnectionNode = targetNode.view()->createModelNode("Connections");
+#else
+    NodeMetaInfo connectionsMetaInfo = targetNode.view()->model()->qtQmlConnectionsMetaInfo();
     const auto typeName = useProjectStorage() ? "Connections" : "QtQuick.Connections";
     ModelNode newConnectionNode = targetNode.view()->createModelNode(
         typeName, connectionsMetaInfo.majorVersion(), connectionsMetaInfo.minorVersion());
+#endif
     if (QmlItemNode::isValidQmlItemNode(targetNode)) {
         targetNode.nodeAbstractProperty("data").reparentHere(newConnectionNode);
     } else {
@@ -874,20 +878,9 @@ public:
         NodeMetaInfo modelMetaInfo = view->model()->metaInfo("ListModel");
         NodeMetaInfo elementMetaInfo = view->model()->metaInfo("ListElement");
 
-        ListModelEditorModel model{[&] {
+#ifdef QDS_USE_PROJECTSTORAGE
-                                       return view->createModelNode(useProjectStorage()
+        ListModelEditorModel model{[&] { return view->createModelNode("ListModel"); },
-                                                                        ? "ListModel"
+                                   [&] { return view->createModelNode("ListElement"); },
-                                                                        : "QtQml.Models.ListModel",
-                                                                    modelMetaInfo.majorVersion(),
-                                                                    modelMetaInfo.minorVersion());
-                                   },
-                                   [&] {
-                                       return view->createModelNode(
-                                           useProjectStorage() ? "ListElement"
-                                                               : "QtQml.Models.ListElement",
-                                           elementMetaInfo.majorVersion(),
-                                           elementMetaInfo.minorVersion());
-                                   },
                                    [&](const ModelNode &node) {
                                        bool isNowInComponent = ModelNodeOperations::goIntoComponent(
                                            node);
@@ -906,6 +899,33 @@ public:
 
                                        return node;
                                    }};
+#else
+        ListModelEditorModel model{
+            [&] {
+                return view->createModelNode("QtQml.Models.ListModel",
+                                             modelMetaInfo.majorVersion(),
+                                             modelMetaInfo.minorVersion());
+            },
+            [&] {
+                return view->createModelNode("QtQml.Models.ListElement",
+                                             elementMetaInfo.majorVersion(),
+                                             elementMetaInfo.minorVersion());
+            },
+            [&](const ModelNode &node) {
+                bool isNowInComponent = ModelNodeOperations::goIntoComponent(node);
+
+                Model *currentModel = QmlDesignerPlugin::instance()->currentDesignDocument()->currentModel();
+
+                if (currentModel->rewriterView() && !currentModel->rewriterView()->errors().isEmpty()) {
+                    throw DocumentError{};
+                }
+
+                if (isNowInComponent)
+                    return view->rootModelNode();
+
+                return node;
+            }};
+#endif
 
         model.setListView(targetNode);
 

src/plugins/qmldesigner/components/componentcore/layoutingridlayout.cpp

@@ -169,9 +169,12 @@ void LayoutInGridLayout::doIt()
 
             m_selectionContext.view()->executeInTransaction("LayoutInGridLayout1",[this, &layoutNode, layoutType](){
                 QTC_ASSERT(m_selectionContext.view()->model()->hasNodeMetaInfo(layoutType), return);
-
+#ifdef QDS_USE_PROJECTSTORAGE
+                layoutNode = m_selectionContext.view()->createModelNode(layoutType);
+#else
                 NodeMetaInfo metaInfo = m_selectionContext.view()->model()->metaInfo(layoutType);
                 layoutNode = m_selectionContext.view()->createModelNode(layoutType, metaInfo.majorVersion(), metaInfo.minorVersion());
+#endif
                 reparentTo(layoutNode, m_parentNode);
             });
 
@@ -387,10 +390,13 @@ void LayoutInGridLayout::fillEmptyCells()
                 if (y > 0)
                     yPos = m_yTopOffsets.at(y-1);
 
+#ifdef QDS_USE_PROJECTSTORAGE
+                ModelNode newNode = m_selectionContext.view()->createModelNode("Item");
+#else
                 NodeMetaInfo metaInfo = m_selectionContext.view()->model()->metaInfo("QtQuick.Item");
 
                 ModelNode newNode = m_selectionContext.view()->createModelNode("QtQuick.Item", metaInfo.majorVersion(), metaInfo.minorVersion());
-
+#endif
                 reparentTo(newNode, m_parentNode);
 
                 m_spacerNodes.append(newNode);

src/plugins/qmldesigner/components/componentcore/modelnodeoperations.cpp

@@ -484,11 +484,13 @@ static void layoutHelperFunction(const SelectionContext &selectionContext,
             selectionContext.view()->executeInTransaction("DesignerActionManager|layoutHelperFunction",[=](){
 
                 QmlItemNode parentNode = qmlItemNode.instanceParentItem();
-
+#ifdef QDS_USE_PROJECTSTORAGE
+                const ModelNode layoutNode = selectionContext.view()->createModelNode(layoutType);
+#else
                 NodeMetaInfo metaInfo = selectionContext.view()->model()->metaInfo(layoutType);
 
                 const ModelNode layoutNode = selectionContext.view()->createModelNode(layoutType, metaInfo.majorVersion(), metaInfo.minorVersion());
-
+#endif
                 reparentTo(layoutNode, parentNode);
 
                 QList<ModelNode> sortedSelectedNodes =  selectionContext.selectedModelNodes();
@@ -886,15 +888,26 @@ void addItemToStackedContainer(const SelectionContext &selectionContext)
 
         NodeMetaInfo itemMetaInfo = view->model()->metaInfo("QtQuick.Item", -1, -1);
         QTC_ASSERT(itemMetaInfo.isValid(), return);
-        QTC_ASSERT(itemMetaInfo.majorVersion() == 2, return);
+#ifdef QDS_USE_PROJECTSTORAGE
-
+        QmlDesigner::ModelNode itemNode = view->createModelNode("Item");
+#else
         QmlDesigner::ModelNode itemNode =
                 view->createModelNode("QtQuick.Item", itemMetaInfo.majorVersion(), itemMetaInfo.minorVersion());
-
+#endif
         container.defaultNodeListProperty().reparentHere(itemNode);
 
         if (potentialTabBar.isValid()) {// The stacked container is hooked up to a TabBar
-            NodeMetaInfo tabButtonMetaInfo = view->model()->metaInfo("QtQuick.Controls.TabButton", -1, -1);
+#ifdef QDS_USE_PROJECTSTORAGE
+            const int buttonIndex = potentialTabBar.directSubModelNodes().size();
+            ModelNode tabButtonNode = view->createModelNode("TabButton");
+
+            tabButtonNode.variantProperty("text").setValue(
+                QString::fromLatin1("Tab %1").arg(buttonIndex));
+            potentialTabBar.defaultNodeListProperty().reparentHere(tabButtonNode);
+#else
+            NodeMetaInfo tabButtonMetaInfo = view->model()->metaInfo("QtQuick.Controls.TabButton",
+                                                                     -1,
+                                                                     -1);
             if (tabButtonMetaInfo.isValid()) {
                 const int buttonIndex = potentialTabBar.directSubModelNodes().size();
                 ModelNode tabButtonNode =
@@ -906,6 +919,7 @@ void addItemToStackedContainer(const SelectionContext &selectionContext)
                 potentialTabBar.defaultNodeListProperty().reparentHere(tabButtonNode);
 
             }
+#endif
         }
     });
 }
@@ -1005,6 +1019,7 @@ void addTabBarToStackedContainer(const SelectionContext &selectionContext)
     QTC_ASSERT(container.isValid(), return);
     QTC_ASSERT(container.metaInfo().isValid(), return);
 
+#ifndef QDS_USE_PROJECTSTORAGE
     NodeMetaInfo tabBarMetaInfo = view->model()->metaInfo("QtQuick.Controls.TabBar", -1, -1);
     QTC_ASSERT(tabBarMetaInfo.isValid(), return);
     QTC_ASSERT(tabBarMetaInfo.majorVersion() == 2, return);
@@ -1012,6 +1027,7 @@ void addTabBarToStackedContainer(const SelectionContext &selectionContext)
     NodeMetaInfo tabButtonMetaInfo = view->model()->metaInfo("QtQuick.Controls.TabButton", -1, -1);
     QTC_ASSERT(tabButtonMetaInfo.isValid(), return);
     QTC_ASSERT(tabButtonMetaInfo.majorVersion() == 2, return);
+#endif
 
     QmlItemNode containerItemNode(container);
     QTC_ASSERT(containerItemNode.isValid(), return);
@@ -1019,14 +1035,15 @@ void addTabBarToStackedContainer(const SelectionContext &selectionContext)
     const PropertyName indexPropertyName = getIndexPropertyName(container);
     QTC_ASSERT(container.metaInfo().hasProperty(indexPropertyName), return);
 
-    view->executeInTransaction("DesignerActionManager:addItemToStackedContainer",
+    view->executeInTransaction("DesignerActionManager:addItemToStackedContainer", [&]() {
-                               [view, container, containerItemNode, tabBarMetaInfo, tabButtonMetaInfo, indexPropertyName](){
+#ifdef QDS_USE_PROJECTSTORAGE
-
+        ModelNode tabBarNode = view->createModelNode("TabBar");
+#else
         ModelNode tabBarNode =
                 view->createModelNode("QtQuick.Controls.TabBar",
                                       tabBarMetaInfo.majorVersion(),
                                       tabBarMetaInfo.minorVersion());
-
+#endif
         container.parentProperty().reparentHere(tabBarNode);
 
         const int maxValue = container.directSubModelNodes().size();
@@ -1038,11 +1055,14 @@ void addTabBarToStackedContainer(const SelectionContext &selectionContext)
         tabBarItem.anchors().setAnchor(AnchorLineBottom, containerItemNode, AnchorLineTop);
 
         for (int i = 0; i < maxValue; ++i) {
+#ifdef QDS_USE_PROJECTSTORAGE
+            ModelNode tabButtonNode = view->createModelNode("TabButton");
+#else
             ModelNode tabButtonNode =
                     view->createModelNode("QtQuick.Controls.TabButton",
                                           tabButtonMetaInfo.majorVersion(),
                                           tabButtonMetaInfo.minorVersion());
-
+#endif
             tabButtonNode.variantProperty("text").setValue(QString::fromLatin1("Tab %1").arg(i));
             tabBarNode.defaultNodeListProperty().reparentHere(tabButtonNode);
         }
@@ -1053,7 +1073,6 @@ void addTabBarToStackedContainer(const SelectionContext &selectionContext)
         const QString expression = id + "." + QString::fromLatin1(indexPropertyName);
         container.bindingProperty(indexPropertyName).setExpression(expression);
     });
-
 }
 
 AddFilesResult addFilesToProject(const QStringList &fileNames, const QString &defaultDir, bool showDialog)
@@ -1170,23 +1189,22 @@ void createFlowActionArea(const SelectionContext &selectionContext)
 
     const QPointF pos = selectionContext.scenePosition().isNull() ? QPointF() : selectionContext.scenePosition() - QmlItemNode(container).flowPosition();
 
-    view->executeInTransaction("DesignerActionManager:createFlowActionArea",
+    view->executeInTransaction("DesignerActionManager:createFlowActionArea", [&]() {
-                               [view, container, actionAreaMetaInfo, pos](){
+#ifdef QDS_USE_PROJECTSTORAGE
-
+        ModelNode flowActionNode = view->createModelNode("FlowActionArea");
-                                   ModelNode flowActionNode =
+#else
-                                       view->createModelNode("FlowView.FlowActionArea",
+            ModelNode flowActionNode = view->createModelNode("FlowView.FlowActionArea",
                                                              actionAreaMetaInfo.majorVersion(),
                                                              actionAreaMetaInfo.minorVersion());
+#endif
+        if (!pos.isNull()) {
+            flowActionNode.variantProperty("x").setValue(pos.x());
+            flowActionNode.variantProperty("y").setValue(pos.y());
+        }
 
-                                   if (!pos.isNull()) {
+        container.defaultNodeListProperty().reparentHere(flowActionNode);
-                                       flowActionNode.variantProperty("x").setValue(pos.x());
+        view->setSelectedModelNode(flowActionNode);
-                                       flowActionNode.variantProperty("y").setValue(pos.y());
+    });
-                                   }
-
-                                   container.defaultNodeListProperty().reparentHere(flowActionNode);
-                                   view->setSelectedModelNode(flowActionNode);
-                               });
-
 }
 
 void addTransition(const SelectionContext &selectionContext)
@@ -1221,17 +1239,18 @@ void addFlowEffect(const SelectionContext &selectionContext, const TypeName &typ
    NodeMetaInfo effectMetaInfo = view->model()->metaInfo("FlowView." + typeName, -1, -1);
    QTC_ASSERT(typeName == "None" || effectMetaInfo.isValid(), return);
 
-   view->executeInTransaction("DesignerActionManager:addFlowEffect", [=]() {
+   view->executeInTransaction("DesignerActionManager:addFlowEffect", [&]() {
        if (container.hasProperty("effect"))
            container.removeProperty("effect");
 
        if (effectMetaInfo.isQtObject()) {
-           ModelNode effectNode = view->createModelNode(useProjectStorage()
+#ifdef QDS_USE_PROJECTSTORAGE
-                                                            ? typeName
+           ModelNode effectNode = view->createModelNode(typeName);
-                                                            : effectMetaInfo.typeName(),
+#else
+           ModelNode effectNode = view->createModelNode(effectMetaInfo.typeName(),
                                                         effectMetaInfo.majorVersion(),
                                                         effectMetaInfo.minorVersion());
-
+#endif
            container.nodeProperty("effect").reparentHere(effectNode);
            view->setSelectedModelNode(effectNode);
        }
@@ -1299,7 +1318,6 @@ void reparentToNodeAndAdjustPosition(const ModelNode &parentModelNode,
 
 void addToGroupItem(const SelectionContext &selectionContext)
 {
-    const TypeName typeName = "QtQuick.Studio.Components.GroupItem";
 
     try {
         if (!hasStudioComponentsImport(selectionContext)) {
@@ -1315,20 +1333,28 @@ void addToGroupItem(const SelectionContext &selectionContext)
 
             if (qmlItemNode.hasInstanceParentItem()) {
                 ModelNode groupNode;
-                selectionContext.view()->executeInTransaction("DesignerActionManager|addToGroupItem1",[=, &groupNode](){
+                selectionContext.view()
+                    ->executeInTransaction("DesignerActionManager|addToGroupItem1", [&]() {
+                        QmlItemNode parentNode = qmlItemNode.instanceParentItem();
+#ifdef QDS_USE_PROJECTSTORAGE
+                        groupNode = selectionContext.view()->createModelNode("GroupItem");
+#else
+                        const TypeName typeName = "QtQuick.Studio.Components.GroupItem";
 
-                    QmlItemNode parentNode = qmlItemNode.instanceParentItem();
+                        NodeMetaInfo metaInfo = selectionContext.view()->model()->metaInfo(typeName);
-                    NodeMetaInfo metaInfo = selectionContext.view()->model()->metaInfo(typeName);
+                        groupNode = selectionContext.view()->createModelNode(typeName,
-                    groupNode = selectionContext.view()->createModelNode(typeName, metaInfo.majorVersion(), metaInfo.minorVersion());
+                                                                             metaInfo.majorVersion(),
-                    reparentTo(groupNode, parentNode);
+                                                                             metaInfo.minorVersion());
-                });
+#endif
-                selectionContext.view()->executeInTransaction("DesignerActionManager|addToGroupItem2",[=](){
+                        reparentTo(groupNode, parentNode);
+                    });
+                selectionContext.view()
+                    ->executeInTransaction("DesignerActionManager|addToGroupItem2", [&]() {
+                        QList<ModelNode> selectedNodes = selectionContext.selectedModelNodes();
+                        setUpperLeftPostionToNode(groupNode, selectedNodes);
 
-                    QList<ModelNode> selectedNodes = selectionContext.selectedModelNodes();
+                        reparentToNodeAndAdjustPosition(groupNode, selectedNodes);
-                    setUpperLeftPostionToNode(groupNode, selectedNodes);
+                    });
-
-                    reparentToNodeAndAdjustPosition(groupNode, selectedNodes);
-                });
             }
         }
     } catch (RewritingException &e) {
@@ -1387,7 +1413,6 @@ static void getTypeAndImport(const SelectionContext &selectionContext,
 
 void addCustomFlowEffect(const SelectionContext &selectionContext)
 {
-
     TypeName typeName;
 
     QString typeString;
@@ -1416,23 +1441,27 @@ void addCustomFlowEffect(const SelectionContext &selectionContext)
     QTC_ASSERT(container.metaInfo().isValid(), return);
     QTC_ASSERT(QmlItemNode::isFlowTransition(container), return);
 
+#ifndef QDS_USE_PROJECTSTORAGE
     NodeMetaInfo effectMetaInfo = view->model()->metaInfo(typeName, -1, -1);
     QTC_ASSERT(typeName == "None" || effectMetaInfo.isValid(), return);
-
+#endif
-    view->executeInTransaction("DesignerActionManager:addFlowEffect", [=]() {
+    view->executeInTransaction("DesignerActionManager:addFlowEffect", [&]() {
         if (container.hasProperty("effect"))
             container.removeProperty("effect");
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        ModelNode effectNode = view->createModelNode(typeName);
+        container.nodeProperty("effect").reparentHere(effectNode);
+        view->setSelectedModelNode(effectNode);
+#else
         if (effectMetaInfo.isValid()) {
-            ModelNode effectNode = view->createModelNode(useProjectStorage()
+            ModelNode effectNode = view->createModelNode(effectMetaInfo.typeName(),
-                                                             ? typeName
-                                                             : effectMetaInfo.typeName(),
                                                          effectMetaInfo.majorVersion(),
                                                          effectMetaInfo.minorVersion());
-
             container.nodeProperty("effect").reparentHere(effectNode);
             view->setSelectedModelNode(effectNode);
         }
+#endif
     });
 }
 
@@ -1450,7 +1479,6 @@ static QString fromCamelCase(const QString &s)
 
 QString getTemplateDialog(const Utils::FilePath &projectPath)
 {
-
     const Utils::FilePath templatesPath = projectPath.pathAppended("templates");
 
     const QStringList templateFiles = QDir(templatesPath.toString()).entryList({"*.qml"});
@@ -1598,23 +1626,30 @@ void addMouseAreaFill(const SelectionContext &selectionContext)
         return;
     }
 
-    selectionContext.view()->executeInTransaction("DesignerActionManager|addMouseAreaFill", [selectionContext]() {
+    selectionContext.view()
-        ModelNode modelNode = selectionContext.currentSingleSelectedNode();
+        ->executeInTransaction("DesignerActionManager|addMouseAreaFill", [selectionContext]() {
-        if (modelNode.isValid()) {
+            ModelNode modelNode = selectionContext.currentSingleSelectedNode();
-            NodeMetaInfo itemMetaInfo = selectionContext.view()->model()->metaInfo("QtQuick.MouseArea", -1, -1);
+            if (modelNode.isValid()) {
-            QTC_ASSERT(itemMetaInfo.isValid(), return);
+#ifdef QDS_USE_PROJECTSTORAGE
+                QmlDesigner::ModelNode mouseAreaNode = selectionContext.view()->createModelNode(
+                    "MouseArea");
+#else
+                NodeMetaInfo itemMetaInfo = selectionContext.view()->model()->metaInfo(
+                    "QtQuick.MouseArea", -1, -1);
+                QTC_ASSERT(itemMetaInfo.isValid(), return);
 
-            QmlDesigner::ModelNode mouseAreaNode =
+                QmlDesigner::ModelNode mouseAreaNode = selectionContext.view()->createModelNode(
-                selectionContext.view()->createModelNode("QtQuick.MouseArea", itemMetaInfo.majorVersion(), itemMetaInfo.minorVersion());
+                    "QtQuick.MouseArea", itemMetaInfo.majorVersion(), itemMetaInfo.minorVersion());
-            mouseAreaNode.validId();
+#endif
+                mouseAreaNode.validId();
 
-            modelNode.defaultNodeListProperty().reparentHere(mouseAreaNode);
+                modelNode.defaultNodeListProperty().reparentHere(mouseAreaNode);
-            QmlItemNode mouseAreaItemNode(mouseAreaNode);
+                QmlItemNode mouseAreaItemNode(mouseAreaNode);
-            if (mouseAreaItemNode.isValid()) {
+                if (mouseAreaItemNode.isValid()) {
-                mouseAreaItemNode.anchors().fill();
+                    mouseAreaItemNode.anchors().fill();
+                }
             }
-        }
+        });
-    });
 }
 
 QVariant previewImageDataForGenericNode(const ModelNode &modelNode)

src/plugins/qmldesigner/components/connectioneditor/backendmodel.cpp

@@ -228,16 +228,17 @@ void BackendModel::addNewBackend()
         if (!dialog.isSingleton()) {
             m_connectionView->executeInTransaction("BackendModel::addNewBackend",
                                                    [this, metaInfo, typeName, propertyName, &dialog] {
-                int minorVersion = metaInfo.minorVersion();
-                int majorVersion = metaInfo.majorVersion();
 
                 if (dialog.localDefinition()) {
-                    ModelNode newNode = m_connectionView->createModelNode(useProjectStorage()
+#ifdef QDS_USE_PROJECTSTORAGE
-                                                                              ? typeName.toUtf8()
+                    ModelNode newNode = m_connectionView->createModelNode(typeName.toUtf8());
-                                                                              : metaInfo.typeName(),
+#else
+                    int minorVersion = metaInfo.minorVersion();
+                    int majorVersion = metaInfo.majorVersion();
+                    ModelNode newNode = m_connectionView->createModelNode(metaInfo.typeName(),
                                                                           majorVersion,
                                                                           minorVersion);
-
+#endif
                     m_connectionView->rootModelNode().nodeProperty(propertyName.toUtf8()).setDynamicTypeNameAndsetModelNode(
                                 typeName.toUtf8(), newNode);
                 } else {

src/plugins/qmldesigner/components/connectioneditor/connectionmodel.cpp

@@ -48,7 +48,7 @@ QStringList propertyNameListToStringList(const QmlDesigner::PropertyNameList &pr
 
 bool isConnection(const QmlDesigner::ModelNode &modelNode)
 {
-    return (modelNode.metaInfo().simplifiedTypeName() == "Connections");
+    return modelNode.metaInfo().isQtQmlConnections();
 }
 
 } //namespace
@@ -361,15 +361,14 @@ void ConnectionModel::addConnection(const PropertyName &signalName)
     ModelNode rootModelNode = connectionView()->rootModelNode();
 
     if (rootModelNode.isValid() && rootModelNode.metaInfo().isValid()) {
-
+#ifndef QDS_USE_PROJECTSTORAGE
-        NodeMetaInfo nodeMetaInfo = connectionView()->model()->qtQuickConnectionsMetaInfo();
+        NodeMetaInfo nodeMetaInfo = connectionView()->model()->qtQmlConnectionsMetaInfo();
 
         if (nodeMetaInfo.isValid()) {
-            ModelNode selectedNode;
+#endif
-            if (connectionView()->selectedModelNodes().isEmpty())
+            ModelNode selectedNode = connectionView()->firstSelectedModelNode();
+            if (!selectedNode)
                 selectedNode = connectionView()->rootModelNode();
-            else
-                selectedNode = connectionView()->selectedModelNodes().constFirst();
 
             PropertyName signalHandlerName = signalName;
             if (signalHandlerName.isEmpty())
@@ -378,12 +377,14 @@ void ConnectionModel::addConnection(const PropertyName &signalName)
             signalHandlerName = addOnToSignalName(QString::fromUtf8(signalHandlerName)).toUtf8();
 
             connectionView()
-                ->executeInTransaction("ConnectionModel::addConnection",
+                ->executeInTransaction("ConnectionModel::addConnection", [&] {
-                                       [this, nodeMetaInfo, signalHandlerName, &rootModelNode] {
+#ifdef QDS_USE_PROJECTSTORAGE
-                    ModelNode newNode = connectionView()
+                    ModelNode newNode = connectionView()->createModelNode("Connections");
-                                            ->createModelNode("QtQuick.Connections",
+#else
-                                                              nodeMetaInfo.majorVersion(),
+                    ModelNode newNode = connectionView()->createModelNode("QtQuick.Connections",
-                                                              nodeMetaInfo.minorVersion());
+                                                                          nodeMetaInfo.majorVersion(),
+                                                                          nodeMetaInfo.minorVersion());
+#endif
                     QString source = "console.log(\"clicked\")";
 
                     if (connectionView()->selectedModelNodes().size() == 1) {
@@ -411,7 +412,9 @@ void ConnectionModel::addConnection(const PropertyName &signalName)
 
                     selectProperty(newNode.signalHandlerProperty(signalHandlerName));
                 });
+#ifndef QDS_USE_PROJECTSTORAGE
         }
+#endif
     }
 }
 

src/plugins/qmldesigner/components/createtexture.cpp

@@ -84,10 +84,13 @@ ModelNode CreateTexture::createTextureFromImage(const  Utils::FilePath &assetPat
 
     ModelNode newTexNode = Utils3D::getTextureDefaultInstance(textureSource, m_view);
     if (!newTexNode.isValid()) {
+#ifdef QDS_USE_PROJECTSTORAGE
+        newTexNode = m_view->createModelNode("Texture");
+#else
         newTexNode = m_view->createModelNode("QtQuick3D.Texture",
                                              metaInfo.majorVersion(),
                                              metaInfo.minorVersion());
-
+#endif
         newTexNode.setIdWithoutRefactoring(m_view->model()->generateNewId(assetPath.baseName()));
 
         VariantProperty sourceProp = newTexNode.variantProperty("source");

src/plugins/qmldesigner/components/debugview/debugview.cpp

@@ -95,7 +95,9 @@ void DebugView::nodeCreated(const ModelNode &createdNode)
         message << createdNode.nodeSource();
         message << "MetaInfo " << createdNode.metaInfo().isValid() << " ";
         if (auto metaInfo = createdNode.metaInfo()) {
+#ifndef QDS_USE_PROJECTSTORAGE
             message << metaInfo.majorVersion() << "." << metaInfo.minorVersion();
+#endif
             message << ModelUtils::componentFilePath(createdNode);
         }
         log("::nodeCreated:", message.readAll());
@@ -283,6 +285,7 @@ void DebugView::selectedNodesChanged(const QList<ModelNode> &selectedNodes /*sel
         message << lineBreak;
 
         if (selectedNode.metaInfo().isValid()) {
+#ifndef QDS_USE_PROJECTSTORAGE
             for (const NodeMetaInfo &metaInfo : selectedNode.metaInfo().selfAndPrototypes()) {
                 message << metaInfo.typeName() << " " << metaInfo.majorVersion() << "."
                         << metaInfo.minorVersion() << lineBreak;
@@ -290,6 +293,7 @@ void DebugView::selectedNodesChanged(const QList<ModelNode> &selectedNodes /*sel
 
             message << lineBreak;
             message << selectedNode.metaInfo().typeName();
+#endif
             message << lineBreak;
 
             message << "Node Source" << selectedNode.nodeSource();
@@ -323,10 +327,11 @@ void DebugView::selectedNodesChanged(const QList<ModelNode> &selectedNodes /*sel
         message << "Is valid object node: " << QmlItemNode::isValidQmlObjectNode(selectedNode);
         message << lineBreak;
 
+#ifndef QDS_USE_PROJECTSTORAGE
         message << "version: "
                 << QString::number(selectedNode.metaInfo().majorVersion()) + "."
                        + QString::number(selectedNode.metaInfo().minorVersion());
-
+#endif
         message << lineBreak;
 
         QmlItemNode itemNode(selectedNode);

src/plugins/qmldesigner/components/edit3d/bakelightsdatamodel.cpp

@@ -353,10 +353,14 @@ void BakeLightsDataModel::apply()
         if (node.hasBindingProperty(propName))
             blmNode = node.bindingProperty(propName).resolveToModelNode();
         if (!blmNode.isValid() && data.enabled) {
+#ifdef QDS_USE_PROJECTSTORAGE
+            blmNode = m_view->createModelNode("BakedLightmap");
+#else
             NodeMetaInfo metaInfo = m_view->model()->qtQuick3DBakedLightmapMetaInfo();
             blmNode = m_view->createModelNode("QtQuick3D.BakedLightmap",
                                           metaInfo.majorVersion(),
                                           metaInfo.minorVersion());
+#endif
             QString idPart;
             if (data.aliasProp.isEmpty())
                 idPart = data.id;

src/plugins/qmldesigner/components/itemlibrary/itemlibrarymodel.cpp

@@ -371,10 +371,13 @@ void ItemLibraryModel::update([[maybe_unused]] ItemLibraryInfo *itemLibraryInfo,
         else
             metaInfo = model->metaInfo(entry.typeName());
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        bool valid = metaInfo.isValid();
+#else
         bool valid = metaInfo.isValid()
                      && (metaInfo.majorVersion() >= entry.majorVersion()
                          || metaInfo.majorVersion() < 0);
-
+#endif
         bool isItem = valid && metaInfo.isQtQuickItem();
         bool forceVisibility = valid && NodeHints::fromItemLibraryEntry(entry).visibleInLibrary();
 

src/plugins/qmldesigner/components/materialbrowser/materialutils.cpp

@@ -47,10 +47,14 @@ void MaterialUtils::assignMaterialTo3dModel(AbstractView *view, const ModelNode
 
         // if no valid material, create a new default material
         if (!newMaterialNode.isValid()) {
+#ifdef QDS_USE_PROJECTSTORAGE
+            newMaterialNode = view->createModelNode("PrincipledMaterial");
+#else
             NodeMetaInfo metaInfo = view->model()->qtQuick3DPrincipledMaterialMetaInfo();
             newMaterialNode = view->createModelNode("QtQuick3D.PrincipledMaterial",
                                                     metaInfo.majorVersion(),
                                                     metaInfo.minorVersion());
+#endif
             newMaterialNode.validId();
         }
     }

src/plugins/qmldesigner/components/materialeditor/materialeditorqmlbackend.cpp

@@ -287,8 +287,10 @@ void MaterialEditorQmlBackend::setup(const QmlObjectNode &selectedMaterialNode,
 
         contextObject()->setSelectionChanged(false);
 
+#ifndef QDS_USE_PROJECTSTORAGE
         NodeMetaInfo metaInfo = selectedMaterialNode.modelNode().metaInfo();
         contextObject()->setMajorVersion(metaInfo.isValid() ? metaInfo.majorVersion() : -1);
+#endif
     } else {
         context()->setContextProperty("hasMaterial", QVariant(false));
     }

src/plugins/qmldesigner/components/materialeditor/materialeditorview.cpp

@@ -419,11 +419,14 @@ void MaterialEditorView::handleToolBarAction(int action)
             ModelNode matLib = Utils3D::materialLibraryNode(this);
             if (!matLib.isValid())
                 return;
-
+#ifdef QDS_USE_PROJECTSTORAGE
+            ModelNode newMatNode = createModelNode("PrincipledMaterial");
+#else
             NodeMetaInfo metaInfo = model()->qtQuick3DPrincipledMaterialMetaInfo();
             ModelNode newMatNode = createModelNode("QtQuick3D.PrincipledMaterial",
                                                    metaInfo.majorVersion(),
                                                    metaInfo.minorVersion());
+#endif
             renameMaterial(newMatNode, "New Material");
             matLib.defaultNodeListProperty().reparentHere(newMatNode);
         });
@@ -526,6 +529,10 @@ void MaterialEditorView::handlePreviewModelChanged(const QString &modelStr)
 
 void MaterialEditorView::setupQmlBackend()
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+// TODO unify implementation with property editor view
+#else
+
     QUrl qmlPaneUrl;
     QUrl qmlSpecificsUrl;
     QString specificQmlData;
@@ -603,6 +610,7 @@ void MaterialEditorView::setupQmlBackend()
 
     m_stackedWidget->setCurrentWidget(m_qmlBackEnd->widget());
     m_stackedWidget->setMinimumSize({400, 300});
+#endif
 }
 
 void MaterialEditorView::commitVariantValueToModel(const PropertyName &propertyName, const QVariant &value)
@@ -1037,9 +1045,12 @@ void MaterialEditorView::duplicateMaterial(const ModelNode &material)
             return;
 
         // create the duplicate material
+#ifdef QDS_USE_PROJECTSTORAGE
+        QmlObjectNode duplicateMat = createModelNode(matType);
+#else
         NodeMetaInfo metaInfo = model()->metaInfo(matType);
         QmlObjectNode duplicateMat = createModelNode(matType, metaInfo.majorVersion(), metaInfo.minorVersion());
-
+#endif
         duplicateMatNode = duplicateMat.modelNode();
 
         // set name and id

src/plugins/qmldesigner/components/navigator/choosefrompropertylistdialog.cpp

@@ -97,9 +97,13 @@ ChooseFromPropertyListFilter::ChooseFromPropertyListFilter(const NodeMetaInfo &i
     } else if (insertInfo.isQtQuick3DMaterial()) {
         if (parentInfo.isQtQuick3DModel())
             propertyList.append("materials");
+#ifdef QDS_USE_PROJECTSTORAGE
+// TODO add the types here or use the module
+#else
     } else if (insertInfo.typeName().startsWith("ComponentBundles.MaterialBundle")) {
         if (parentInfo.isQtQuick3DModel())
             propertyList.append("materials");
+#endif
     } else if (insertInfo.isQtQuick3DBakedLightmap()) {
         if (parentInfo.isQtQuick3DModel())
             propertyList.append("bakedLightmap");

src/plugins/qmldesigner/components/navigator/navigatorview.cpp

@@ -271,14 +271,20 @@ void NavigatorView::dragStarted(QMimeData *mimeData)
     } else if (mimeData->hasFormat(Constants::MIME_TYPE_TEXTURE)) {
         qint32 internalId = mimeData->data(Constants::MIME_TYPE_TEXTURE).toInt();
         ModelNode texNode = modelNodeForInternalId(internalId);
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        m_widget->setDragType(texNode.type());
+#else
         m_widget->setDragType(texNode.metaInfo().typeName());
+#endif
         m_widget->update();
     } else if (mimeData->hasFormat(Constants::MIME_TYPE_MATERIAL)) {
         qint32 internalId = mimeData->data(Constants::MIME_TYPE_MATERIAL).toInt();
         ModelNode matNode = modelNodeForInternalId(internalId);
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        m_widget->setDragType(matNode.type());
+#else
         m_widget->setDragType(matNode.metaInfo().typeName());
+#endif
         m_widget->update();
     } else if (mimeData->hasFormat(Constants::MIME_TYPE_BUNDLE_TEXTURE)) {
         m_widget->setDragType(Constants::MIME_TYPE_BUNDLE_TEXTURE);

src/plugins/qmldesigner/components/propertyeditor/gradientmodel.cpp

@@ -695,6 +695,10 @@ void GradientModel::resetPuppet()
 
 QmlDesigner::ModelNode GradientModel::createGradientNode()
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+    QmlDesigner::TypeName typeName = m_gradientTypeName.toUtf8();
+    auto gradientNode = view()->createModelNode(typeName);
+#else
     QmlDesigner::TypeName fullTypeName = m_gradientTypeName.toUtf8();
 
     if (m_gradientTypeName == "Gradient") {
@@ -709,7 +713,7 @@ QmlDesigner::ModelNode GradientModel::createGradientNode()
     int majorVersion = metaInfo.majorVersion();
 
     auto gradientNode = view()->createModelNode(fullTypeName, majorVersion, minorVersion);
-
+#endif
     setupGradientProperties(gradientNode);
 
     return gradientNode;
@@ -717,6 +721,9 @@ QmlDesigner::ModelNode GradientModel::createGradientNode()
 
 QmlDesigner::ModelNode GradientModel::createGradientStopNode()
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+    return view()->createModelNode("GradientStop");
+#else
     QByteArray fullTypeName = "QtQuick.GradientStop";
     auto metaInfo = model()->metaInfo(fullTypeName);
 
@@ -724,6 +731,7 @@ QmlDesigner::ModelNode GradientModel::createGradientStopNode()
     int majorVersion = metaInfo.majorVersion();
 
     return view()->createModelNode(fullTypeName, majorVersion, minorVersion);
+#endif
 }
 
 void GradientModel::deleteGradientNode(bool saveTransaction)

src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.cpp

@@ -10,11 +10,12 @@
 #include <auxiliarydataproperties.h>
 #include <bindingproperty.h>
 #include <nodemetainfo.h>
-#include <variantproperty.h>
+#include <projectstorage/sourcepathcache.h>
 #include <qmldesignerconstants.h>
 #include <qmldesignerplugin.h>
 #include <qmlobjectnode.h>
 #include <qmltimeline.h>
+#include <variantproperty.h>
 
 #include <theme.h>
 
@@ -514,6 +515,12 @@ void PropertyEditorQmlBackend::setup(const QmlObjectNode &qmlObjectNode, const Q
 
         NodeMetaInfo metaInfo = qmlObjectNode.modelNode().metaInfo();
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        contextObject()->setMajorVersion(-1);
+        contextObject()->setMinorVersion(-1);
+        contextObject()->setMajorQtQuickVersion(-1);
+        contextObject()->setMinorQtQuickVersion(-1);
+#else
         if (metaInfo.isValid()) {
             contextObject()->setMajorVersion(metaInfo.majorVersion());
             contextObject()->setMinorVersion(metaInfo.minorVersion());
@@ -523,7 +530,7 @@ void PropertyEditorQmlBackend::setup(const QmlObjectNode &qmlObjectNode, const Q
             contextObject()->setMajorQtQuickVersion(-1);
             contextObject()->setMinorQtQuickVersion(-1);
         }
-
+#endif
         contextObject()->setMajorQtQuickVersion(qmlObjectNode.view()->majorQtQuickVersion());
         contextObject()->setMinorQtQuickVersion(qmlObjectNode.view()->minorQtQuickVersion());
 
@@ -619,6 +626,7 @@ inline bool dotPropertyHeuristic(const QmlObjectNode &node, const NodeMetaInfo &
     return true;
 }
 
+#ifndef QDS_USE_PROJECTSTORAGE
 QString PropertyEditorQmlBackend::templateGeneration(const NodeMetaInfo &metaType,
                                                      const NodeMetaInfo &superType,
                                                      const QmlObjectNode &node)
@@ -849,6 +857,7 @@ QUrl PropertyEditorQmlBackend::getQmlFileUrl(const TypeName &relativeTypeName, c
 {
     return fileToUrl(locateQmlFile(info, QString::fromUtf8(fixTypeNameForPanes(relativeTypeName) + ".qml")));
 }
+#endif // QDS_USE_PROJECTSTORAGE
 
 TypeName PropertyEditorQmlBackend::fixTypeNameForPanes(const TypeName &typeName)
 {
@@ -883,11 +892,13 @@ NodeMetaInfo PropertyEditorQmlBackend::findCommonAncestor(const ModelNode &node)
     return node.metaInfo();
 }
 
+#ifndef QDS_USE_PROJECTSTORAGE
 TypeName PropertyEditorQmlBackend::qmlFileName(const NodeMetaInfo &nodeInfo)
 {
     const TypeName fixedTypeName = fixTypeNameForPanes(nodeInfo.typeName());
     return fixedTypeName + "Pane.qml";
 }
+#endif
 
 QUrl PropertyEditorQmlBackend::fileToUrl(const QString &filePath)  {
     QUrl fileUrl;
@@ -963,6 +974,7 @@ void PropertyEditorQmlBackend::setValueforAuxiliaryProperties(const QmlObjectNod
     setValue(qmlObjectNode, propertyName, qmlObjectNode.modelNode().auxiliaryDataWithDefault(key));
 }
 
+#ifndef QDS_USE_PROJECTSTORAGE
 std::tuple<QUrl, NodeMetaInfo> PropertyEditorQmlBackend::getQmlUrlForMetaInfo(const NodeMetaInfo &metaInfo)
 {
     QString className;
@@ -1026,7 +1038,7 @@ QString PropertyEditorQmlBackend::locateQmlFile(const NodeMetaInfo &info, const
         return QFileInfo::exists(possibleFilePath);
     });
 }
-
+#endif // QDS_USE_PROJECTSTORAGE
 
 } //QmlDesigner
 

src/plugins/qmldesigner/components/propertyeditor/propertyeditorqmlbackend.h

@@ -48,10 +48,13 @@ public:
     PropertyEditorValue *propertyValueForName(const QString &propertyName);
 
     static QString propertyEditorResourcesPath();
-    static QString templateGeneration(const NodeMetaInfo &type, const NodeMetaInfo &superType, const QmlObjectNode &node);
+#ifndef QDS_USE_PROJECTSTORAGE
-
+    static QString templateGeneration(const NodeMetaInfo &type,
+                                      const NodeMetaInfo &superType,
+                                      const QmlObjectNode &node);
     static QUrl getQmlFileUrl(const TypeName &relativeTypeName, const NodeMetaInfo &info);
     static std::tuple<QUrl, NodeMetaInfo> getQmlUrlForMetaInfo(const NodeMetaInfo &modelNode);
+#endif
 
     static bool checkIfUrlExists(const QUrl &url);
 
@@ -80,10 +83,12 @@ private:
                                   PropertyEditorView *propertyEditor,
                                   const NodeMetaInfo &type);
 
-    static TypeName qmlFileName(const NodeMetaInfo &nodeInfo);
     static QUrl fileToUrl(const QString &filePath);
     static QString fileFromUrl(const QUrl &url);
+#ifndef QDS_USE_PROJECTSTORAGE
+    static TypeName qmlFileName(const NodeMetaInfo &nodeInfo);
     static QString locateQmlFile(const NodeMetaInfo &info, const QString &relativePath);
+#endif
     static TypeName fixTypeNameForPanes(const TypeName &typeName);
 
 private:

src/plugins/qmldesigner/components/propertyeditor/propertyeditorvalue.cpp

@@ -579,6 +579,15 @@ void PropertyEditorNodeWrapper::add(const QString &type)
     TypeName propertyType = type.toUtf8();
 
     if ((m_editorValue && m_editorValue->modelNode().isValid())) {
+#ifdef QDS_USE_PROJECTSTORAGE
+        if (propertyType.isEmpty()) {
+            auto node = m_editorValue->modelNode();
+            auto metaInfo = node.metaInfo().property(m_editorValue->name()).propertyType();
+            auto exportedTypeName = node.model()->exportedTypeNameForMetaInfo(metaInfo);
+            propertyType = exportedTypeName.name.toQByteArray();
+        }
+        m_modelNode = m_editorValue->modelNode().view()->createModelNode(propertyType);
+#else
         if (propertyType.isEmpty()) {
             propertyType = m_editorValue->modelNode()
                                .metaInfo()
@@ -589,6 +598,7 @@ void PropertyEditorNodeWrapper::add(const QString &type)
         while (propertyType.contains('*')) // strip star
             propertyType.chop(1);
         m_modelNode = m_editorValue->modelNode().view()->createModelNode(propertyType, 4, 7);
+#endif
         m_editorValue->modelNode().nodeAbstractProperty(m_editorValue->name()).reparentHere(m_modelNode);
         if (!m_modelNode.isValid())
             qWarning("PropertyEditorNodeWrapper::add failed");

src/plugins/qmldesigner/components/propertyeditor/propertyeditorview.cpp

@@ -96,8 +96,9 @@ PropertyEditorView::~PropertyEditorView()
     qDeleteAll(m_qmlBackendHash);
 }
 
-void PropertyEditorView::setupPane(const TypeName &typeName)
+void PropertyEditorView::setupPane([[maybe_unused]] const TypeName &typeName)
 {
+#ifndef QDS_USE_PROJECTSTORAGE
     NodeMetaInfo metaInfo = model()->metaInfo(typeName);
 
     QUrl qmlFile = PropertyEditorQmlBackend::getQmlFileUrl("Qt/ItemPane", metaInfo);
@@ -118,6 +119,7 @@ void PropertyEditorView::setupPane(const TypeName &typeName)
     } else {
         qmlBackend->initialSetup(typeName, qmlSpecificsFile, this);
     }
+#endif // QDS_USE_PROJECTSTORAGE
 }
 
 void PropertyEditorView::changeValue(const QString &name)
@@ -448,6 +450,7 @@ void PropertyEditorView::resetView()
 
 namespace {
 
+#ifndef QDS_USE_PROJECTSTORAGE
 [[maybe_unused]] std::tuple<NodeMetaInfo, QUrl> diffType(const NodeMetaInfo &commonAncestor,
                                                          const NodeMetaInfo &specificsClassMetaInfo)
 {
@@ -483,6 +486,7 @@ namespace {
 
     return {};
 }
+#endif // QDS_USE_PROJECTSTORAGE
 
 PropertyEditorQmlBackend *getQmlBackend(QHash<QString, PropertyEditorQmlBackend *> &qmlBackendHash,
                                         const QUrl &qmlFileUrl,
@@ -572,63 +576,56 @@ void setupWidget(PropertyEditorQmlBackend *currentQmlBackend,
 
 void PropertyEditorView::setupQmlBackend()
 {
-    if constexpr (useProjectStorage()) {
+#ifdef QDS_USE_PROJECTSTORAGE
-        auto selfAndPrototypes = m_selectedNode.metaInfo().selfAndPrototypes();
+    auto selfAndPrototypes = m_selectedNode.metaInfo().selfAndPrototypes();
-        bool isEditableComponent = m_selectedNode.isComponent()
+    bool isEditableComponent = m_selectedNode.isComponent()
-                                   && !QmlItemNode(m_selectedNode).isEffectItem();
+                               && !QmlItemNode(m_selectedNode).isEffectItem();
-        auto specificQmlData = m_propertyEditorComponentGenerator.create(selfAndPrototypes,
+    auto specificQmlData = m_propertyEditorComponentGenerator.create(selfAndPrototypes,
-                                                                         isEditableComponent);
+                                                                     isEditableComponent);
-        auto [panePath, specificsPath] = findPaneAndSpecificsPath(selfAndPrototypes,
+    auto [panePath, specificsPath] = findPaneAndSpecificsPath(selfAndPrototypes, model()->pathCache());
-                                                                  model()->pathCache());
+    PropertyEditorQmlBackend *currentQmlBackend = getQmlBackend(m_qmlBackendHash,
-        PropertyEditorQmlBackend *currentQmlBackend = getQmlBackend(m_qmlBackendHash,
+                                                                QUrl::fromLocalFile(QString{panePath}),
-                                                                    QUrl::fromLocalFile(
+                                                                m_imageCache,
-                                                                        QString{panePath}),
+                                                                m_stackedWidget,
-                                                                    m_imageCache,
+                                                                this);
-                                                                    m_stackedWidget,
-                                                                    this);
 
-        setupCurrentQmlBackend(currentQmlBackend,
+    setupCurrentQmlBackend(currentQmlBackend,
-                               m_selectedNode,
+                           m_selectedNode,
-                               QUrl::fromLocalFile(QString{specificsPath}),
+                           QUrl::fromLocalFile(QString{specificsPath}),
-                               currentState(),
+                           currentState(),
-                               this,
+                           this,
-                               specificQmlData);
+                           specificQmlData);
 
-        setupWidget(currentQmlBackend, this, m_stackedWidget);
+    setupWidget(currentQmlBackend, this, m_stackedWidget);
 
-        m_qmlBackEndForCurrentType = currentQmlBackend;
+    m_qmlBackEndForCurrentType = currentQmlBackend;
 
-        setupInsight(rootModelNode(), currentQmlBackend);
+    setupInsight(rootModelNode(), currentQmlBackend);
-    } else {
+#else
-        const NodeMetaInfo commonAncestor = PropertyEditorQmlBackend::findCommonAncestor(
+    const NodeMetaInfo commonAncestor = PropertyEditorQmlBackend::findCommonAncestor(m_selectedNode);
-            m_selectedNode);
 
-        const auto [qmlFileUrl, specificsClassMetaInfo] = PropertyEditorQmlBackend::getQmlUrlForMetaInfo(
+    const auto [qmlFileUrl, specificsClassMetaInfo] = PropertyEditorQmlBackend::getQmlUrlForMetaInfo(
-            commonAncestor);
+        commonAncestor);
 
-        auto [diffClassMetaInfo, qmlSpecificsFile] = diffType(commonAncestor, specificsClassMetaInfo);
+    auto [diffClassMetaInfo, qmlSpecificsFile] = diffType(commonAncestor, specificsClassMetaInfo);
 
-        QString specificQmlData = getSpecificQmlData(commonAncestor, m_selectedNode, diffClassMetaInfo);
+    QString specificQmlData = getSpecificQmlData(commonAncestor, m_selectedNode, diffClassMetaInfo);
 
-        PropertyEditorQmlBackend *currentQmlBackend = getQmlBackend(m_qmlBackendHash,
+    PropertyEditorQmlBackend *currentQmlBackend = getQmlBackend(m_qmlBackendHash,
-                                                                    qmlFileUrl,
+                                                                qmlFileUrl,
-                                                                    m_imageCache,
+                                                                m_imageCache,
-                                                                    m_stackedWidget,
+                                                                m_stackedWidget,
-                                                                    this);
+                                                                this);
 
-        setupCurrentQmlBackend(currentQmlBackend,
+    setupCurrentQmlBackend(
-                               m_selectedNode,
+        currentQmlBackend, m_selectedNode, qmlSpecificsFile, currentState(), this, specificQmlData);
-                               qmlSpecificsFile,
-                               currentState(),
-                               this,
-                               specificQmlData);
 
-        setupWidget(currentQmlBackend, this, m_stackedWidget);
+    setupWidget(currentQmlBackend, this, m_stackedWidget);
 
-        m_qmlBackEndForCurrentType = currentQmlBackend;
+    m_qmlBackEndForCurrentType = currentQmlBackend;
 
-        setupInsight(rootModelNode(), currentQmlBackend);
+    setupInsight(rootModelNode(), currentQmlBackend);
-    }
+#endif // QDS_USE_PROJECTSTORAGE
 }
 
 void PropertyEditorView::commitVariantValueToModel(const PropertyName &propertyName, const QVariant &value)

src/plugins/qmldesigner/components/stateseditor/propertymodel.cpp

@@ -64,12 +64,19 @@ QVariant PropertyModel::data(const QModelIndex &index, int role) const
 
         if (!propertyChanges.target().isValid())
             return {};
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        return propertyChanges.target()
+            .metaInfo()
+            .property(m_properties.at(index.row()).name())
+            .propertyType()
+            .displayName();
+#else
         return propertyChanges.target()
             .metaInfo()
             .property(m_properties.at(index.row()).name())
             .propertyType()
             .typeName();
+#endif
     }
     }
     return {};

src/plugins/qmldesigner/components/stateseditor/stateseditormodel.cpp

@@ -343,6 +343,9 @@ bool StatesEditorModel::renameActiveStateGroup(const QString &name)
 void StatesEditorModel::addStateGroup(const QString &name)
 {
     m_statesEditorView->executeInTransaction("createStateGroup", [this, name]() {
+#ifdef QDS_USE_PROJECTSTORAGE
+        auto stateGroupNode = m_statesEditorView->createModelNode("StateGroup");
+#else
         const TypeName typeName = "QtQuick.StateGroup";
         auto metaInfo = m_statesEditorView->model()->metaInfo(typeName);
         int minorVersion = metaInfo.minorVersion();
@@ -350,6 +353,7 @@ void StatesEditorModel::addStateGroup(const QString &name)
         auto stateGroupNode = m_statesEditorView->createModelNode(typeName,
                                                                   majorVersion,
                                                                   minorVersion);
+#endif
         stateGroupNode.setIdWithoutRefactoring(m_statesEditorView->model()->generateNewId(name));
 
         m_statesEditorView->rootModelNode().defaultNodeAbstractProperty().reparentHere(

src/plugins/qmldesigner/components/textureeditor/textureeditorqmlbackend.cpp

@@ -247,8 +247,10 @@ void TextureEditorQmlBackend::setup(const QmlObjectNode &selectedTextureNode, co
 
         contextObject()->setSelectionChanged(false);
 
+#ifndef QDS_USE_PROJECTSTORAGE
         NodeMetaInfo metaInfo = selectedTextureNode.modelNode().metaInfo();
         contextObject()->setMajorVersion(metaInfo.isValid() ? metaInfo.majorVersion() : -1);
+#endif
     } else {
         context()->setContextProperty("hasTexture", QVariant(false));
     }

src/plugins/qmldesigner/components/textureeditor/textureeditorview.cpp

@@ -380,10 +380,14 @@ void TextureEditorView::handleToolBarAction(int action)
             ModelNode matLib = Utils3D::materialLibraryNode(this);
             if (!matLib.isValid())
                 return;
-
+#ifdef QDS_USE_PROJECTSTORAGE
+            ModelNode newTextureNode = createModelNode("Texture");
+#else
             NodeMetaInfo metaInfo = model()->metaInfo("QtQuick3D.Texture");
-            ModelNode newTextureNode = createModelNode("QtQuick3D.Texture", metaInfo.majorVersion(),
+            ModelNode newTextureNode = createModelNode("QtQuick3D.Texture",
-                                                                            metaInfo.minorVersion());
+                                                       metaInfo.majorVersion(),
+                                                       metaInfo.minorVersion());
+#endif
             newTextureNode.validId();
             matLib.defaultNodeListProperty().reparentHere(newTextureNode);
         });
@@ -408,6 +412,9 @@ void TextureEditorView::handleToolBarAction(int action)
 
 void TextureEditorView::setupQmlBackend()
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+// This is an copy of the property editor code which is already rewritten. Please reuse that code.
+#else
     QUrl qmlPaneUrl;
     QUrl qmlSpecificsUrl;
     QString specificQmlData;
@@ -475,6 +482,7 @@ void TextureEditorView::setupQmlBackend()
         m_dynamicPropertiesModel->reset();
 
     m_stackedWidget->setCurrentWidget(m_qmlBackEnd->widget());
+#endif
 }
 
 void TextureEditorView::commitVariantValueToModel(const PropertyName &propertyName, const QVariant &value)
@@ -754,9 +762,12 @@ void TextureEditorView::duplicateTexture(const ModelNode &texture)
             return;
 
         // create the duplicate texture
+#ifdef QDS_USE_PROJECTSTORAGE
+        QmlObjectNode duplicateTex = createModelNode(matType);
+#else
         NodeMetaInfo metaInfo = model()->metaInfo(matType);
         QmlObjectNode duplicateTex = createModelNode(matType, metaInfo.majorVersion(), metaInfo.minorVersion());
-
+#endif
         duplicateTextureNode = duplicateTex .modelNode();
         duplicateTextureNode.validId();
 

src/plugins/qmldesigner/components/timelineeditor/timelineview.cpp

@@ -278,6 +278,7 @@ TimelineWidget *TimelineView::widget() const
     return m_timelineWidget;
 }
 
+namespace {
 QList<QmlModelState> getAllStates(TimelineView* view)
 {
     QmlVisualNode visNode(view->rootModelNode());
@@ -315,6 +316,7 @@ void enableInCurrentState(
         }
     }
 }
+} // namespace
 
 const QmlTimeline TimelineView::addNewTimeline()
 {
@@ -329,21 +331,24 @@ const QmlTimeline TimelineView::addNewTimeline()
     } catch (const Exception &e) {
         e.showException();
     }
-
+#ifndef QDS_USE_PROJECTSTORAGE
     NodeMetaInfo metaInfo = model()->metaInfo(timelineType);
 
     QTC_ASSERT(metaInfo.isValid(), return QmlTimeline());
-
+#endif
     ModelNode timelineNode;
 
-    executeInTransaction("TimelineView::addNewTimeline",
+    executeInTransaction("TimelineView::addNewTimeline", [&] {
-                         [this, timelineType, metaInfo, &timelineNode] {
         bool hasTimelines = getTimelines().isEmpty();
         QString currentStateName = getStateName(this, hasTimelines);
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        timelineNode = createModelNode("Timeline");
+#else
         timelineNode = createModelNode(timelineType,
                                        metaInfo.majorVersion(),
                                        metaInfo.minorVersion());
+#endif
         timelineNode.validId();
 
         timelineNode.variantProperty("startFrame").setValue(0);
@@ -366,21 +371,25 @@ ModelNode TimelineView::addAnimation(QmlTimeline timeline)
 
     QTC_ASSERT(isAttached(), return ModelNode());
 
+#ifndef QDS_USE_PROJECTSTORAGE
     NodeMetaInfo metaInfo = model()->metaInfo(animationType);
 
     QTC_ASSERT(metaInfo.isValid(), return ModelNode());
-
+#endif
     ModelNode animationNode;
 
-    executeInTransaction("TimelineView::addAnimation",
+    executeInTransaction("TimelineView::addAnimation", [&] {
-                         [this, timeline, animationType, metaInfo, &animationNode] {
         bool hasAnimations = getAnimations(timeline).isEmpty();
         QString currentStateName = getStateName(this, hasAnimations);
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        animationNode = createModelNode("TimelineAnimation");
+#else
         animationNode = createModelNode(animationType,
                                         metaInfo.majorVersion(),
                                         metaInfo.minorVersion());
         animationNode.variantProperty("duration").setValue(timeline.duration());
+#endif
         animationNode.validId();
 
         animationNode.variantProperty("from").setValue(timeline.startKeyframe());

src/plugins/qmldesigner/components/transitioneditor/transitioneditorview.cpp

@@ -225,8 +225,19 @@ ModelNode TransitionEditorView::addNewTransition()
 
     if (!idPropertyList.isEmpty()) {
         executeInTransaction(
-                    " TransitionEditorView::addNewTransition", [&transition, idPropertyList, root, this]() {
+            " TransitionEditorView::addNewTransition", [&transition, idPropertyList, root, this]() {
 
+#ifdef QDS_USE_PROJECTSTORAGE
+                transition = createModelNode("Transition",
+                                             {{
+                                                  "from",
+                                                  "*",
+                                              },
+                                              {
+                                                  "to",
+                                                  "*",
+                                              }});
+#else
             const NodeMetaInfo transitionMetaInfo = model()->metaInfo("QtQuick.Transition");
             transition = createModelNode("QtQuick.Transition",
                                          transitionMetaInfo.majorVersion(),
@@ -239,28 +250,38 @@ ModelNode TransitionEditorView::addNewTransition()
                                               "to",
                                               "*",
                                           }});
-            transition.setAuxiliaryData(transitionDurationProperty, 2000);
+#endif
-            transition.validId();
+                transition.setAuxiliaryData(transitionDurationProperty, 2000);
-            root.nodeListProperty("transitions").reparentHere(transition);
+                transition.validId();
+                root.nodeListProperty("transitions").reparentHere(transition);
 
-            for (auto it = idPropertyList.cbegin(); it != idPropertyList.cend(); ++it) {
+                for (auto it = idPropertyList.cbegin(); it != idPropertyList.cend(); ++it) {
-                ModelNode parallelAnimation = createModelNode("QtQuick.ParallelAnimation");
+                    ModelNode parallelAnimation = createModelNode("QtQuick.ParallelAnimation");
-                transition.defaultNodeAbstractProperty().reparentHere(parallelAnimation);
+                    transition.defaultNodeAbstractProperty().reparentHere(parallelAnimation);
-                for (const QString &property : it.value()) {
+                    for (const QString &property : it.value()) {
-                    ModelNode sequentialAnimation
+                        ModelNode sequentialAnimation = createModelNode(
-                            = createModelNode("QtQuick.SequentialAnimation");
+                            "QtQuick.SequentialAnimation");
-                    parallelAnimation.defaultNodeAbstractProperty().reparentHere(
+                        parallelAnimation.defaultNodeAbstractProperty().reparentHere(
-                                sequentialAnimation);
+                            sequentialAnimation);
 
+#ifdef QDS_USE_PROJECTSTORAGE
+                        ModelNode pauseAnimation = createModelNode("PauseAnimation",
+                                                                   {{"duration", 50}});
+#else
                     const NodeMetaInfo pauseMetaInfo = model()->metaInfo("QtQuick.PauseAnimation");
 
                     ModelNode pauseAnimation = createModelNode("QtQuick.PauseAnimation",
                                                                pauseMetaInfo.majorVersion(),
                                                                pauseMetaInfo.minorVersion(),
                                                                {{"duration", 50}});
-                    sequentialAnimation.defaultNodeAbstractProperty().reparentHere(
+#endif
-                                pauseAnimation);
+                        sequentialAnimation.defaultNodeAbstractProperty().reparentHere(pauseAnimation);
 
+#ifdef QDS_USE_PROJECTSTORAGE
+                        ModelNode propertyAnimation = createModelNode("PropertyAnimation",
+                                                                      {{"property", property},
+                                                                       {"duration", 150}});
+#else
                     const NodeMetaInfo propertyMetaInfo = model()->metaInfo("QtQuick.PauseAnimation");
 
                     ModelNode propertyAnimation = createModelNode("QtQuick.PropertyAnimation",
@@ -268,11 +289,12 @@ ModelNode TransitionEditorView::addNewTransition()
                                                                   propertyMetaInfo.minorVersion(),
                                                                   {{"property", property},
                                                                    {"duration", 150}});
-                    propertyAnimation.bindingProperty("target").setExpression(it.key());
+#endif
-                    sequentialAnimation.defaultNodeAbstractProperty().reparentHere(
+                        propertyAnimation.bindingProperty("target").setExpression(it.key());
-                                propertyAnimation);
+                        sequentialAnimation.defaultNodeAbstractProperty().reparentHere(
+                            propertyAnimation);
+                    }
                 }
-            }
             });
     } else {
         QString properties;

src/plugins/qmldesigner/designercore/include/abstractview.h

@@ -95,6 +95,13 @@ public:
                               ModelNode::NodeSourceType nodeSourceType = ModelNode::NodeWithoutSource,
                               const QString &behaviorPropertyName = {});
 
+    ModelNode createModelNode(const TypeName &typeName,
+                              const PropertyListType &propertyList,
+                              const AuxiliaryDatas &auxPropertyList = {},
+                              const QString &nodeSource = {},
+                              ModelNode::NodeSourceType nodeSourceType = ModelNode::NodeWithoutSource,
+                              const QString &behaviorPropertyName = {});
+
     ModelNode rootModelNode() const;
     ModelNode rootModelNode();
 

src/plugins/qmldesigner/designercore/include/model.h

@@ -110,13 +110,14 @@ public:
                                       fileUrl,
                                       std::move(resourceManagement)));
     }
-    static ModelPointer create(ProjectStorageDependencies m_projectStorageDependencies,
+
+    static ModelPointer create(ProjectStorageDependencies projectStorageDependencies,
                                const TypeName &typeName,
                                int major = 1,
                                int minor = 1,
                                std::unique_ptr<ModelResourceManagementInterface> resourceManagement = {})
     {
-        return ModelPointer(new Model(m_projectStorageDependencies,
+        return ModelPointer(new Model(projectStorageDependencies,
                                       typeName,
                                       major,
                                       minor,
@@ -124,6 +125,9 @@ public:
                                       std::move(resourceManagement)));
     }
 
+    ModelPointer createModel(const TypeName &typeName,
+                             std::unique_ptr<ModelResourceManagementInterface> resourceManagement = {});
+
     QUrl fileUrl() const;
     SourceId fileUrlSourceId() const;
     void setFileUrl(const QUrl &url);
@@ -150,6 +154,7 @@ public:
     NodeMetaInfo flowViewFlowWildcardMetaInfo() const;
     NodeMetaInfo fontMetaInfo() const;
     NodeMetaInfo qmlQtObjectMetaInfo() const;
+    NodeMetaInfo qtQmlConnectionsMetaInfo() const;
     NodeMetaInfo qtQmlModelsListModelMetaInfo() const;
     NodeMetaInfo qtQmlModelsListElementMetaInfo() const;
     NodeMetaInfo qtQuick3DBakedLightmapMetaInfo() const;
@@ -164,7 +169,6 @@ public:
     NodeMetaInfo qtQuick3DPrincipledMaterialMetaInfo() const;
     NodeMetaInfo qtQuick3DSpotLightMetaInfo() const;
     NodeMetaInfo qtQuick3DTextureMetaInfo() const;
-    NodeMetaInfo qtQuickConnectionsMetaInfo() const;
     NodeMetaInfo qtQuickControlsTextAreaMetaInfo() const;
     NodeMetaInfo qtQuickImageMetaInfo() const;
     NodeMetaInfo qtQuickItemMetaInfo() const;
@@ -216,6 +220,10 @@ public:
     QStringList importPaths() const;
     Import highestPossibleImport(const QString &importPath);
 
+    ModuleIds moduleIds() const;
+
+    Storage::Info::ExportedTypeName exportedTypeNameForMetaInfo(const NodeMetaInfo &metaInfo) const;
+
     RewriterView *rewriterView() const;
     void setRewriterView(RewriterView *rewriterView);
 

src/plugins/qmldesigner/designercore/include/nodemetainfo.h

@@ -22,6 +22,16 @@ QT_BEGIN_NAMESPACE
 class QDeclarativeContext;
 QT_END_NAMESPACE
 
+#ifdef QDS_USE_PROJECTSTORAGE
+#  define DEPRECATED_TYPENAME [[deprecated("Don't use string based types anymore!")]]
+#  define DEPRECATED_VERSION_NUMBER \
+      [[deprecated( \
+          "In most cases you don't need them anymore because the import is setting them!")]]
+#else
+#  define DEPRECATED_TYPENAME
+#  define DEPRECATED_VERSION_NUMBER
+#endif
+
 namespace QmlDesigner {
 
 class MetaInfo;
@@ -92,10 +102,11 @@ public:
 
     bool defaultPropertyIsComponent() const;
 
-    TypeName typeName() const;
+    TypeName displayName() const;
-    TypeName simplifiedTypeName() const;
+    DEPRECATED_TYPENAME TypeName typeName() const;
-    int majorVersion() const;
+    DEPRECATED_TYPENAME TypeName simplifiedTypeName() const;
-    int minorVersion() const;
+    DEPRECATED_VERSION_NUMBER int majorVersion() const;
+    DEPRECATED_VERSION_NUMBER int minorVersion() const;
 
     Storage::Info::ExportedTypeNames allExportedTypeNames() const;
     Storage::Info::ExportedTypeNames exportedTypeNamesForSourceId(SourceId sourceId) const;
@@ -155,6 +166,7 @@ public:
     bool isQmlComponent() const;
     bool isQtMultimediaSoundEffect() const;
     bool isQtObject() const;
+    bool isQtQmlConnections() const;
     bool isQtQuick3DBakedLightmap() const;
     bool isQtQuick3DBuffer() const;
     bool isQtQuick3DCamera() const;
@@ -202,6 +214,7 @@ public:
     bool isQtQuickState() const;
     bool isQtQuickStateOperation() const;
     bool isQtQuickStudioComponentsGroupItem() const;
+    bool isQtQuickStudioUtilsJsonListModel() const;
     bool isQtQuickText() const;
     bool isQtQuickTimelineKeyframe() const;
     bool isQtQuickTimelineKeyframeGroup() const;

src/plugins/qmldesigner/designercore/metainfo/nodemetainfo.cpp

@@ -26,6 +26,12 @@
 #include <utils/qtcassert.h>
 #include <utils/algorithm.h>
 
+// remove that if the old code model is removed
+QT_WARNING_PUSH
+QT_WARNING_DISABLE_GCC("-Wdeprecated-declarations")
+QT_WARNING_DISABLE_CLANG("-Wdeprecated-declarations")
+QT_WARNING_DISABLE_MSVC(4996)
+
 namespace QmlDesigner {
 
 /*!
@@ -1924,6 +1930,11 @@ bool NodeMetaInfo::defaultPropertyIsComponent() const
     return false;
 }
 
+TypeName NodeMetaInfo::displayName() const
+{
+    return {};
+}
+
 TypeName NodeMetaInfo::typeName() const
 {
     if (isValid())
@@ -2365,6 +2376,16 @@ bool NodeMetaInfo::isQtObject() const
     }
 }
 
+bool NodeMetaInfo::isQtQmlConnections() const
+{
+    if constexpr (useProjectStorage()) {
+        using namespace Storage::Info;
+        return isBasedOnCommonType<QtQml, Connections>(m_projectStorage, m_typeId);
+    } else {
+        return isValid() && simplifiedTypeName() == "Connections";
+    }
+}
+
 bool NodeMetaInfo::isLayoutable() const
 {
     if constexpr (useProjectStorage()) {
@@ -3014,6 +3035,17 @@ bool NodeMetaInfo::isQtQuickStudioComponentsGroupItem() const
     }
 }
 
+bool NodeMetaInfo::isQtQuickStudioUtilsJsonListModel() const
+{
+    if constexpr (useProjectStorage()) {
+        using namespace Storage::Info;
+        return isBasedOnCommonType<QtQuick_Studio_Components, JsonListModel>(m_projectStorage,
+                                                                             m_typeId);
+    } else {
+        return isValid() && isSubclassOf("QtQuick.Studio.Utils.JsonListModel");
+    }
+}
+
 bool NodeMetaInfo::isQmlComponent() const
 {
     if constexpr (useProjectStorage()) {
@@ -3689,3 +3721,5 @@ CompoundPropertyMetaInfos MetaInfoUtils::inflateValueAndReadOnlyProperties(Prope
 }
 
 } // namespace QmlDesigner
+
+QT_WARNING_POP

src/plugins/qmldesigner/designercore/model/abstractview.cpp

@@ -68,12 +68,12 @@ RewriterTransaction AbstractView::beginRewriterTransaction(const QByteArray &ide
 
 ModelNode AbstractView::createModelNode(const TypeName &typeName)
 {
-    if constexpr (useProjectStorage()) {
+#ifdef QDS_USE_PROJECTSTORAGE
-        return createModelNode(typeName, -1, -1);
+    return createModelNode(typeName, -1, -1);
-    } else {
+#else
-        const NodeMetaInfo metaInfo = model()->metaInfo(typeName);
+    const NodeMetaInfo metaInfo = model()->metaInfo(typeName);
-        return createModelNode(typeName, metaInfo.majorVersion(), metaInfo.minorVersion());
+    return createModelNode(typeName, metaInfo.majorVersion(), metaInfo.minorVersion());
-    }
+#endif
 }
 
 ModelNode AbstractView::createModelNode(const TypeName &typeName,
@@ -90,6 +90,24 @@ ModelNode AbstractView::createModelNode(const TypeName &typeName,
                                             behaviorPropertyName), model(), this);
 }
 
+ModelNode AbstractView::createModelNode(const TypeName &typeName,
+                                        const QList<QPair<PropertyName, QVariant>> &propertyList,
+                                        const AuxiliaryDatas &auxPropertyList,
+                                        const QString &nodeSource,
+                                        ModelNode::NodeSourceType nodeSourceType,
+                                        const QString &behaviorPropertyName)
+{
+    return ModelNode(model()->d->createNode(typeName,
+                                            -1,
+                                            -1,
+                                            propertyList,
+                                            auxPropertyList,
+                                            nodeSource,
+                                            nodeSourceType,
+                                            behaviorPropertyName),
+                     model(),
+                     this);
+}
 
 // Returns the constant root model node.
 ModelNode AbstractView::rootModelNode() const
@@ -824,6 +842,7 @@ static int getMajorVersionFromImport(const Model *model)
     return -1;
 }
 
+#ifndef QDS_USE_PROJECTSTORAGE
 static int getMajorVersionFromNode(const ModelNode &modelNode)
 {
     if (modelNode.metaInfo().isValid()) {
@@ -848,6 +867,7 @@ static int getMinorVersionFromNode(const ModelNode &modelNode)
 
     return 1; // default
 }
+#endif
 
 int AbstractView::majorQtQuickVersion() const
 {
@@ -855,7 +875,11 @@ int AbstractView::majorQtQuickVersion() const
     if (majorVersionFromImport >= 0)
         return majorVersionFromImport;
 
+#ifdef QDS_USE_PROJECTSTORAGE
+    return -1;
+#else
     return getMajorVersionFromNode(rootModelNode());
+#endif
 }
 
 int AbstractView::minorQtQuickVersion() const
@@ -864,7 +888,11 @@ int AbstractView::minorQtQuickVersion() const
     if (minorVersionFromImport >= 0)
         return minorVersionFromImport;
 
+#ifdef QDS_USE_PROJECTSTORAGE
+    return -1;
+#else
     return getMinorVersionFromNode(rootModelNode());
+#endif
 }
 
 } // namespace QmlDesigner

src/plugins/qmldesigner/designercore/model/model.cpp

@@ -1731,6 +1731,16 @@ Model::Model(const TypeName &typeName,
         this, typeName, major, minor, metaInfoProxyModel, std::move(resourceManagement)))
 {}
 
+ModelPointer Model::createModel(const TypeName &typeName,
+                                std::unique_ptr<ModelResourceManagementInterface> resourceManagement)
+{
+    return Model::create({*d->projectStorage, *d->pathCache},
+                         typeName,
+                         imports(),
+                         fileUrl(),
+                         std::move(resourceManagement));
+}
+
 Model::~Model() = default;
 
 const Imports &Model::imports() const
@@ -1738,6 +1748,16 @@ const Imports &Model::imports() const
     return d->imports();
 }
 
+ModuleIds Model::moduleIds() const
+{
+    return {};
+}
+
+Storage::Info::ExportedTypeName Model::exportedTypeNameForMetaInfo(const NodeMetaInfo &) const
+{
+    return {};
+}
+
 const Imports &Model::possibleImports() const
 {
     return d->m_possibleImportList;
@@ -1938,7 +1958,6 @@ void Model::setCurrentStateNode(const ModelNode &node)
     d->notifyCurrentStateChanged(node);
 }
 
-// QTC_TEMP
 ModelNode Model::currentStateNode(AbstractView *view)
 {
     return ModelNode(d->currentStateNode(), this, view);
@@ -2455,13 +2474,13 @@ NodeMetaInfo Model::qtQuickTransistionMetaInfo() const
     }
 }
 
-NodeMetaInfo Model::qtQuickConnectionsMetaInfo() const
+NodeMetaInfo Model::qtQmlConnectionsMetaInfo() const
 {
     if constexpr (useProjectStorage()) {
         using namespace Storage::Info;
-        return createNodeMetaInfo<QtQuick, Connections>();
+        return createNodeMetaInfo<QtQml, Connections>();
     } else {
-        return metaInfo("QtQuick.Connections");
+        return metaInfo("QtQml.Connections");
     }
 }
 
@@ -2714,12 +2733,12 @@ ModelNode createNode(Model *model,
 
 ModelNode Model::createModelNode(const TypeName &typeName)
 {
-    if constexpr (useProjectStorage()) {
+#ifdef QDS_USE_PROJECTSTORAGE
-        return createNode(this, d.get(), typeName, -1, -1);
+    return createNode(this, d.get(), typeName, -1, -1);
-    } else {
+#else
-        const NodeMetaInfo m = metaInfo(typeName);
+    const NodeMetaInfo m = metaInfo(typeName);
-        return createNode(this, d.get(), typeName, m.majorVersion(), m.minorVersion());
+    return createNode(this, d.get(), typeName, m.majorVersion(), m.minorVersion());
-    }
+#endif
 }
 
 void Model::changeRootNodeType(const TypeName &type)

src/plugins/qmldesigner/designercore/model/modelmerger.cpp

@@ -152,9 +152,17 @@ static ModelNode createNodeFromNode(const ModelNode &modelNode,
                                     const QHash<QString, QString> &idRenamingHash,
                                     AbstractView *view, const MergePredicate &mergePredicate)
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode newNode = view->createModelNode(modelNode.type(),
+                                              {},
+                                              {},
+                                              modelNode.nodeSource(),
+                                              modelNode.nodeSourceType());
+#else
     NodeMetaInfo nodeMetaInfo = view->model()->metaInfo(modelNode.type());
     ModelNode newNode(view->createModelNode(modelNode.type(), nodeMetaInfo.majorVersion(), nodeMetaInfo.minorVersion(),
                                             {}, {}, modelNode.nodeSource(), modelNode.nodeSourceType()));
+#endif
     syncVariantProperties(newNode, modelNode);
     syncAuxiliaryProperties(newNode, modelNode);
     syncBindingProperties(newNode, modelNode, idRenamingHash);

src/plugins/qmldesigner/designercore/model/qmlconnections.cpp

@@ -98,10 +98,15 @@ QList<SignalHandlerProperty> QmlConnections::signalProperties() const
 
 ModelNode QmlConnections::createQmlConnections(AbstractView *view)
 {
-    NodeMetaInfo nodeMetaInfo = view->model()->qtQuickConnectionsMetaInfo();
+#ifdef QDS_USE_PROJECTSTORAGE
+    return view->createModelNode("Connections");
+#else
+    NodeMetaInfo nodeMetaInfo = view->model()->qtQmlConnectionsMetaInfo();
+
     return view->createModelNode("QtQuick.Connections",
                                  nodeMetaInfo.majorVersion(),
                                  nodeMetaInfo.minorVersion());
+#endif
 }
 
 } // QmlDesigner

src/plugins/qmldesigner/designercore/model/qmlitemnode.cpp

@@ -81,12 +81,25 @@ QmlItemNode QmlItemNode::createQmlItemNodeFromImage(AbstractView *view, const QS
             propertyPairList.append({PropertyName("source"), QVariant(relativeImageName)});
         }
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        TypeName type("Image");
+        QImageReader reader(imageName);
+        if (reader.supportsAnimation())
+            type = "AnimatedImage";
+
+        newQmlItemNode = QmlItemNode(view->createModelNode(type, propertyPairList));
+#else
+
         TypeName type("QtQuick.Image");
         QImageReader reader(imageName);
         if (reader.supportsAnimation())
             type = "QtQuick.AnimatedImage";
 
-        newQmlItemNode = QmlItemNode(view->createModelNode(type, metaInfo.majorVersion(), metaInfo.minorVersion(), propertyPairList));
+        newQmlItemNode = QmlItemNode(view->createModelNode(type,
+                                                           metaInfo.majorVersion(),
+                                                           metaInfo.minorVersion(),
+                                                           propertyPairList));
+#endif
         parentproperty.reparentHere(newQmlItemNode);
 
         QFileInfo fi(relativeImageName);
@@ -129,7 +142,6 @@ QmlItemNode QmlItemNode::createQmlItemNodeFromFont(AbstractView *view,
     QmlItemNode newQmlItemNode;
 
     auto doCreateQmlItemNodeFromFont = [=, &newQmlItemNode, &parentproperty]() {
-        NodeMetaInfo metaInfo = view->model()->metaInfo("QtQuick.Text");
         QList<QPair<PropertyName, QVariant>> propertyPairList;
         if (const int intX = qRound(position.x()))
             propertyPairList.append({PropertyName("x"), QVariant(intX)});
@@ -138,9 +150,13 @@ QmlItemNode QmlItemNode::createQmlItemNodeFromFont(AbstractView *view,
         propertyPairList.append({PropertyName("font.family"), QVariant(fontFamily)});
         propertyPairList.append({PropertyName("font.pointSize"), 20});
         propertyPairList.append({PropertyName("text"), QVariant(fontFamily)});
-
+#ifdef QDS_USE_PROJECTSTORAGE
+        newQmlItemNode = QmlItemNode(view->createModelNode("Text", propertyPairList));
+#else
+        NodeMetaInfo metaInfo = view->model()->metaInfo("QtQuick.Text");
         newQmlItemNode = QmlItemNode(view->createModelNode("QtQuick.Text", metaInfo.majorVersion(),
                                                            metaInfo.minorVersion(), propertyPairList));
+#endif
         parentproperty.reparentHere(newQmlItemNode);
 
         newQmlItemNode.setId(view->model()->generateNewId("text", "text"));

src/plugins/qmldesigner/designercore/model/qmlobjectnode.cpp

@@ -475,7 +475,7 @@ QList<ModelNode> QmlObjectNode::getAllConnections() const
     if (!isValid())
         return {};
 
-    auto list = view()->allModelNodesOfType(model()->qtQuickConnectionsMetaInfo());
+    auto list = view()->allModelNodesOfType(model()->qtQmlConnectionsMetaInfo());
     return Utils::filtered(list, [this](const ModelNode &connection) {
         return connection.hasBindingProperty("target")
                && connection.bindingProperty("target").resolveToModelNode() == modelNode();

src/plugins/qmldesigner/designercore/model/qmlstate.cpp

@@ -141,6 +141,9 @@ void QmlModelState::addChangeSetIfNotExists(const ModelNode &node)
     if (!hasPropertyChanges(node)) {
         ModelNode newChangeSet;
 
+#ifdef QDS_USE_PROJECTSTORAGE
+        newChangeSet = modelNode().view()->createModelNode("PropertyChanges");
+#else
         const QByteArray typeName = "QtQuick.PropertyChanges";
         NodeMetaInfo metaInfo = modelNode().model()->metaInfo(typeName);
 
@@ -148,6 +151,7 @@ void QmlModelState::addChangeSetIfNotExists(const ModelNode &node)
         int minor = metaInfo.minorVersion();
 
         newChangeSet = modelNode().view()->createModelNode(typeName, major, minor);
+#endif
 
         modelNode().nodeListProperty("changes").reparentHere(newChangeSet);
 
@@ -296,6 +300,9 @@ ModelNode QmlModelState::createQmlState(AbstractView *view, const PropertyListTy
 {
     QTC_ASSERT(view, return {});
 
+#ifdef QDS_USE_PROJECTSTORAGE
+    return view->createModelNode("State", propertyList);
+#else
     const QByteArray typeName = "QtQuick.State";
     NodeMetaInfo metaInfo = view->model()->metaInfo(typeName);
 
@@ -303,6 +310,7 @@ ModelNode QmlModelState::createQmlState(AbstractView *view, const PropertyListTy
     int minor = metaInfo.minorVersion();
 
     return view->createModelNode(typeName, major, minor, propertyList);
+#endif
 }
 
 void QmlModelState::setAsDefault()

src/plugins/qmldesigner/designercore/model/qmlvisualnode.cpp

@@ -278,7 +278,11 @@ static QmlObjectNode createQmlObjectNodeFromSource(AbstractView *view,
                                                    const QString &source,
                                                    const QmlVisualNode::Position &position)
 {
+#ifdef QDS_USE_PROJECTSTORAGE
+    auto inputModel = view->model()->createModel("Item");
+#else
     auto inputModel = Model::create("QtQuick.Item", 1, 0, view->model());
+#endif
     inputModel->setFileUrl(view->model()->fileUrl());
     QPlainTextEdit textEdit;
 
@@ -328,11 +332,12 @@ QmlObjectNode QmlVisualNode::createQmlObjectNode(AbstractView *view,
     NodeHints hints = NodeHints::fromItemLibraryEntry(itemLibraryEntry);
 
     auto createNodeFunc = [=, &newQmlObjectNode, &parentProperty]() {
+#ifndef QDS_USE_PROJECTSTORAGE
         NodeMetaInfo metaInfo = view->model()->metaInfo(itemLibraryEntry.typeName());
 
         int minorVersion = metaInfo.minorVersion();
         int majorVersion = metaInfo.majorVersion();
-
+#endif
         using PropertyBindingEntry = QPair<PropertyName, QString>;
         QList<PropertyBindingEntry> propertyBindingList;
         QList<PropertyBindingEntry> propertyEnumList;
@@ -359,7 +364,18 @@ QmlObjectNode QmlVisualNode::createQmlObjectNode(AbstractView *view,
             if (itemLibraryEntry.typeName() == "QtQml.Component")
                 nodeSourceType = ModelNode::NodeWithComponentSource;
 
-            newQmlObjectNode = QmlObjectNode(view->createModelNode(itemLibraryEntry.typeName(), majorVersion, minorVersion, propertyPairList, {}, {}, nodeSourceType));
+#ifdef QDS_USE_PROJECTSTORAGE
+            newQmlObjectNode = QmlObjectNode(view->createModelNode(
+                itemLibraryEntry.typeName(), propertyPairList, {}, {}, nodeSourceType));
+#else
+            newQmlObjectNode = QmlObjectNode(view->createModelNode(itemLibraryEntry.typeName(),
+                                                                   majorVersion,
+                                                                   minorVersion,
+                                                                   propertyPairList,
+                                                                   {},
+                                                                   {},
+                                                                   nodeSourceType));
+#endif
         } else {
             newQmlObjectNode = createQmlObjectNodeFromSource(view, itemLibraryEntry.qmlSource(), position);
         }

src/plugins/qmldesigner/designercore/model/stylesheetmerger.cpp

@@ -169,6 +169,11 @@ ModelNode StylesheetMerger::createReplacementNode(const ModelNode& styleNode, Mo
             continue;
         propertyList.append(QPair<PropertyName, QVariant>(variantProperty.name(), variantProperty.value()));
     }
+
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode newNode(m_templateView->createModelNode(
+        styleNode.type(), propertyList, {}, styleNode.nodeSource(), styleNode.nodeSourceType()));
+#else
     ModelNode newNode(m_templateView->createModelNode(styleNode.type(),
                                                       nodeMetaInfo.majorVersion(),
                                                       nodeMetaInfo.minorVersion(),
@@ -176,6 +181,7 @@ ModelNode StylesheetMerger::createReplacementNode(const ModelNode& styleNode, Mo
                                                       {},
                                                       styleNode.nodeSource(),
                                                       styleNode.nodeSourceType()));
+#endif
 
     syncAuxiliaryProperties(newNode, modelNode);
     syncBindingProperties(newNode, modelNode);
@@ -436,10 +442,14 @@ void StylesheetMerger::syncStateNode(ModelNode &outputState, const ModelNode &in
             changeSet = itr->second;
         } else {
             const QByteArray typeName = inputChangeset.type();
+#ifdef QDS_USE_PROJECTSTORAGE
+            changeSet = m_templateView->createModelNode(typeName);
+#else
             NodeMetaInfo metaInfo = m_templateView->model()->metaInfo(typeName);
             int major = metaInfo.majorVersion();
             int minor = metaInfo.minorVersion();
             changeSet = m_templateView->createModelNode(typeName, major, minor);
+#endif
             outputState.nodeListProperty("changes").reparentHere(changeSet);
             outputChangeSets.insert({key, changeSet});
         }

src/plugins/qmldesigner/designercore/model/texttomodelmerger.cpp

@@ -1192,11 +1192,11 @@ void TextToModelMerger::syncNode(ModelNode &modelNode,
     int majorVersion = -1;
     int minorVersion = -1;
 
-    if constexpr (!useProjectStorage()) {
+#ifndef QDS_USE_PROJECTSTORAGE
-        typeName = info.typeName();
+    typeName = info.typeName();
-        majorVersion = info.majorVersion();
+    majorVersion = info.majorVersion();
-        minorVersion = info.minorVersion();
+    minorVersion = info.minorVersion();
-    }
+#endif
 
     if (modelNode.isRootNode() && !m_rewriterView->allowComponentRoot() && info.isQmlComponent()) {
         for (AST::UiObjectMemberList *iter = astInitializer->members; iter; iter = iter->next) {
@@ -1563,11 +1563,12 @@ void TextToModelMerger::syncNodeProperty(AbstractProperty &modelProperty,
 
     int majorVersion = -1;
     int minorVersion = -1;
-    if constexpr (!useProjectStorage()) {
+
-        typeName = info.typeName();
+#ifndef QDS_USE_PROJECTSTORAGE
-        majorVersion = info.majorVersion();
+    typeName = info.typeName();
-        minorVersion = info.minorVersion();
+    majorVersion = info.majorVersion();
-    }
+    minorVersion = info.minorVersion();
+#endif
 
     if (modelProperty.isNodeProperty() && dynamicPropertyType == modelProperty.dynamicTypeName()) {
         ModelNode nodePropertyNode = modelProperty.toNodeProperty().modelNode();
@@ -2104,11 +2105,11 @@ ModelNode ModelAmender::listPropertyMissingModelNode(NodeListProperty &modelProp
 
     int majorVersion = -1;
     int minorVersion = -1;
-    if constexpr (!useProjectStorage()) {
+#ifndef QDS_USE_PROJECTSTORAGE
-        typeName = info.typeName();
+    typeName = info.typeName();
-        majorVersion = info.majorVersion();
+    majorVersion = info.majorVersion();
-        minorVersion = info.minorVersion();
+    minorVersion = info.minorVersion();
-    }
+#endif
 
     const bool propertyTakesComponent = propertyHasImplicitComponentType(modelProperty, info);
 

src/plugins/qmldesigner/designercore/projectstorage/commontypecache.h

@@ -55,6 +55,7 @@ inline constexpr char InstanceListEntry[] = "InstanceListEntry";
 inline constexpr char InstanceList[] = "InstanceList";
 inline constexpr char IntType[] = "int";
 inline constexpr char Item[] = "Item";
+inline constexpr char JsonListModel[] = "JsonListModel";
 inline constexpr char KeyframeGroup[] = "KeyframeGroup";
 inline constexpr char Keyframe[] = "Keyframe";
 inline constexpr char Layout[] = "Layout";
@@ -171,11 +172,11 @@ class CommonTypeCache
                                    CacheType<QML, var>,
                                    CacheType<QML_cppnative, FloatType>,
                                    CacheType<QML_cppnative, UIntType>,
+                                   CacheType<QtQml, Connections>,
                                    CacheType<QtMultimedia, SoundEffect>,
                                    CacheType<QtQml_Models, ListElement>,
                                    CacheType<QtQml_Models, ListModel>,
                                    CacheType<QtQuick, BorderImage>,
-                                   CacheType<QtQuick, Connections>,
                                    CacheType<QtQuick, GridView>,
                                    CacheType<QtQuick, Image>,
                                    CacheType<QtQuick, Item>,
@@ -243,6 +244,7 @@ class CommonTypeCache
                                    CacheType<QtQuick_Extras, Picture>,
                                    CacheType<QtQuick_Layouts, Layout>,
                                    CacheType<QtQuick_Studio_Components, GroupItem>,
+                                   CacheType<QtQuick_Studio_Components, JsonListModel>,
                                    CacheType<QtQuick_Templates, Control>,
                                    CacheType<QtQuick_Timeline, Keyframe>,
                                    CacheType<QtQuick_Timeline, KeyframeGroup>,

src/plugins/qmldesigner/qmldesignerprojectmanager.cpp

@@ -281,12 +281,12 @@ AsynchronousImageCache &QmlDesignerProjectManager::asynchronousImageCache()
 }
 
 namespace {
-ProjectStorage<Sqlite::Database> *dummyProjectStorage()
+[[maybe_unused]] ProjectStorage<Sqlite::Database> *dummyProjectStorage()
 {
     return nullptr;
 }
 
-ProjectStorageUpdater::PathCache *dummyPathCache()
+[[maybe_unused]] ProjectStorageUpdater::PathCache *dummyPathCache()
 {
     return nullptr;
 }
@@ -383,7 +383,7 @@ void collectQmldirPaths(const QString &path, QStringList &qmldirPaths)
     }
 }
 
-void projectQmldirPaths(::ProjectExplorer::Target *target, QStringList &qmldirPaths)
+[[maybe_unused]] void projectQmldirPaths(::ProjectExplorer::Target *target, QStringList &qmldirPaths)
 {
     ::QmlProjectManager::QmlBuildSystem *buildSystem = getQmlBuildSystem(target);
 
@@ -395,12 +395,22 @@ void projectQmldirPaths(::ProjectExplorer::Target *target, QStringList &qmldirPa
         collectQmldirPaths(importPath, qmldirPaths);
 }
 
-void qtQmldirPaths(::ProjectExplorer::Target *target, QStringList &qmldirPaths)
+[[maybe_unused]] void qtQmldirPaths(::ProjectExplorer::Target *target, QStringList &qmldirPaths)
 {
     if constexpr (useProjectStorage())
         collectQmldirPaths(qmlPath(target).toString(), qmldirPaths);
 }
 
+[[maybe_unused]] void qtQmldirPathsForLiteDesigner(::ProjectExplorer::Target *target,
+                                                   QStringList &qmldirPaths)
+{
+    if constexpr (useProjectStorage()) {
+        auto qmlRootPath = qmlPath(target).toString();
+        collectQmldirPaths(qmlRootPath + "/QtQml", qmldirPaths);
+        collectQmldirPaths(qmlRootPath + "/QtQuick", qmldirPaths);
+    }
+}
+
 QStringList directories(::ProjectExplorer::Target *target)
 {
     if (!target)
@@ -409,8 +419,12 @@ QStringList directories(::ProjectExplorer::Target *target)
     QStringList qmldirPaths;
     qmldirPaths.reserve(100);
 
-    qtQmldirPaths(target, qmldirPaths);
+    if constexpr (isUsingQmlDesignerLite()) {
-    projectQmldirPaths(target, qmldirPaths);
+        qtQmldirPathsForLiteDesigner(target, qmldirPaths);
+    } else {
+        qtQmldirPaths(target, qmldirPaths);
+        projectQmldirPaths(target, qmldirPaths);
+    }
 
     std::sort(qmldirPaths.begin(), qmldirPaths.end());
     qmldirPaths.erase(std::unique(qmldirPaths.begin(), qmldirPaths.end()), qmldirPaths.end());

tests/auto/qml/qmldesigner/coretests/tst_testcore.cpp

@@ -1365,6 +1365,14 @@ void tst_TestCore::testRewriterBehaivours()
 
     QVERIFY(metaInfo.isValid());
 
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode newBehavior = testRewriterView->createModelNode("Behavior",
+                                                              {},
+                                                              {},
+                                                              {},
+                                                              ModelNode::NodeWithoutSource,
+                                                              "height");
+#else
     ModelNode newBehavior = testRewriterView->createModelNode("QtQuick.Behavior",
                                                               metaInfo.majorVersion(),
                                                               metaInfo.minorVersion(),
@@ -1373,17 +1381,20 @@ void tst_TestCore::testRewriterBehaivours()
                                                               {},
                                                               ModelNode::NodeWithoutSource,
                                                               "height");
-
+#endif
     rootModelNode.defaultNodeListProperty().reparentHere(newBehavior);
 
     QCOMPARE(newBehavior.behaviorPropertyName(), "height");
 
     metaInfo = animation.metaInfo();
     QVERIFY(metaInfo.isValid());
+#ifdef QDS_USE_PROJECTSTORAGE
+    ModelNode newAnimation = testRewriterView->createModelNode(model->exportedTypeNameForMetaInfo(metaInfo).name.toQByteArray());
+#else
     ModelNode newAnimation = testRewriterView->createModelNode(metaInfo.typeName(),
                                                                metaInfo.majorVersion(),
                                                                metaInfo.minorVersion());
-
+#endif
     newBehavior.defaultNodeListProperty().reparentHere(newAnimation);
 
     newAnimation.variantProperty("duration").setValue(500);
@@ -1666,8 +1677,10 @@ void tst_TestCore::testStatesVersionFailing()
 
     QCOMPARE(QmlItemNode(rootModelNode).states().state("state2"), newState);
 
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(stateInfo.majorVersion(), newState.modelNode().majorVersion());
     QCOMPARE(stateInfo.minorVersion(), newState.modelNode().minorVersion());
+#endif
 
     ModelNode rect1Node = view->modelNodeForId("rect1");
     QVERIFY(rect1Node.isValid());
@@ -1708,8 +1721,10 @@ void tst_TestCore::testStatesVersionFailing()
     QVERIFY(changes2.modelNode().hasProperty("x"));
     QVERIFY(oldText != textEdit.toPlainText());
 
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(changeInfo.majorVersion(), changes2.modelNode().majorVersion());
     QCOMPARE(changeInfo.minorVersion(), changes2.modelNode().minorVersion());
+#endif
 }
 
 void tst_TestCore::loadSubItems()
@@ -1987,8 +2002,10 @@ void tst_TestCore::testBasicStatesQtQuick20()
     QCOMPARE(rootModelNode.majorVersion(), 2);
     //QCOMPARE(rootModelNode.majorQtQuickVersion(), 2);
 
+#ifndef QDS_USE_PROJECTSTORAGE
     qDebug() << rootModelNode.nodeListProperty("states").toModelNodeList().first().metaInfo().majorVersion();
     qDebug() << rootModelNode.nodeListProperty("states").toModelNodeList().first().metaInfo().typeName();
+#endif
 
     QSKIP("No qml2puppet");
 
@@ -4833,9 +4850,11 @@ void tst_TestCore::testMetaInfoSimpleType()
     NodeMetaInfo itemMetaInfo = model->metaInfo("QtQuick.Item", 2, 1);
 
     QVERIFY(itemMetaInfo.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(itemMetaInfo.typeName(), QmlDesigner::TypeName("QtQuick.Item"));
     QCOMPARE(itemMetaInfo.majorVersion(), 2);
     QCOMPARE(itemMetaInfo.minorVersion(), 1);
+#endif
 
     // super classes
     NodeMetaInfo qobject = itemMetaInfo.prototypes()[1];
@@ -4857,13 +4876,17 @@ void tst_TestCore::testMetaInfoUncreatableType()
     QVERIFY(animationTypeInfo.isValid());
 
     QVERIFY(animationTypeInfo.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(animationTypeInfo.typeName(), QmlDesigner::TypeName("QtQuick.Animation"));
     QCOMPARE(animationTypeInfo.majorVersion(), 2);
     QCOMPARE(animationTypeInfo.minorVersion(), 1);
+#endif
 
     NodeMetaInfo qObjectTypeInfo = animationTypeInfo.prototypes()[1];
     QVERIFY(qObjectTypeInfo.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(qObjectTypeInfo.simplifiedTypeName(), QmlDesigner::TypeName("QtObject"));
+#endif
 
     QCOMPARE(animationTypeInfo.prototypes().size(), 2);
 }
@@ -4903,9 +4926,11 @@ void tst_TestCore::testMetaInfoCustomType()
 
     NodeMetaInfo stateOperationInfo = propertyChangesInfo.prototypes()[1];
     QVERIFY(stateOperationInfo.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(stateOperationInfo.typeName(), QmlDesigner::TypeName("QtQuick.QQuickStateOperation"));
     QCOMPARE(stateOperationInfo.majorVersion(), -1);
     QCOMPARE(stateOperationInfo.minorVersion(), -1);
+#endif
     QCOMPARE(propertyChangesInfo.prototypes().size(), 3);
 
     // DeclarativePropertyChanges just has 3 properties
@@ -4923,25 +4948,31 @@ void tst_TestCore::testMetaInfoEnums()
     QVERIFY(view.data());
     model->attachView(view.data());
 
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(view->rootModelNode().metaInfo().typeName(), QmlDesigner::TypeName("QtQuick.Text"));
+#endif
 
     QVERIFY(view->rootModelNode().metaInfo().hasProperty("transformOrigin"));
 
     QVERIFY(view->rootModelNode().metaInfo().property("transformOrigin").isEnumType());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(view->rootModelNode()
                  .metaInfo()
                  .property("transformOrigin")
                  .propertyType()
                  .simplifiedTypeName(),
              QmlDesigner::TypeName("TransformOrigin"));
+#endif
 
     QVERIFY(view->rootModelNode().metaInfo().property("horizontalAlignment").isEnumType());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(view->rootModelNode()
                  .metaInfo()
                  .property("horizontalAlignment")
                  .propertyType()
                  .simplifiedTypeName(),
              QmlDesigner::TypeName("HAlignment"));
+#endif
 
     QApplication::processEvents();
 }
@@ -5038,10 +5069,12 @@ void tst_TestCore::testMetaInfoDotProperties()
     QVERIFY(model->hasNodeMetaInfo("QtQuick.Text"));
 
     QVERIFY(model->metaInfo("QtQuick.Rectangle").hasProperty("border"));
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(model->metaInfo("QtQuick.Rectangle").property("border").propertyType().typeName(),
              QmlDesigner::TypeName("<cpp>.QQuickPen"));
 
     QCOMPARE(view->rootModelNode().metaInfo().typeName(), QmlDesigner::TypeName("QtQuick.Text"));
+#endif
     QVERIFY(view->rootModelNode().metaInfo().hasProperty("font"));
 
     QVERIFY(view->rootModelNode().metaInfo().hasProperty("font.bold"));
@@ -5071,7 +5104,9 @@ void tst_TestCore::testMetaInfoListProperties()
     model->attachView(view.data());
 
     QVERIFY(model->hasNodeMetaInfo("QtQuick.Item"));
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(view->rootModelNode().metaInfo().typeName(), QmlDesigner::TypeName("QtQuick.Item"));
+#endif
 
     QVERIFY(view->rootModelNode().metaInfo().hasProperty("states"));
     QVERIFY(view->rootModelNode().metaInfo().property("states").isListProperty());
@@ -5108,10 +5143,12 @@ void tst_TestCore::testQtQuick20Basic()
     QVERIFY(testRewriterView->errors().isEmpty());
     ModelNode rootModelNode(testRewriterView->rootModelNode());
     QVERIFY(rootModelNode.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(rootModelNode.metaInfo().majorVersion(), 2);
     QCOMPARE(rootModelNode.metaInfo().minorVersion(), 0);
     //QCOMPARE(rootModelNode.majorQtQuickVersion(), 2);
     QCOMPARE(rootModelNode.majorVersion(), 2);
+#endif
 }
 
 void tst_TestCore::testQtQuick20BasicRectangle()
@@ -5133,11 +5170,13 @@ void tst_TestCore::testQtQuick20BasicRectangle()
     QVERIFY(testRewriterView->errors().isEmpty());
     ModelNode rootModelNode(testRewriterView->rootModelNode());
     QVERIFY(rootModelNode.isValid());
+#ifndef QDS_USE_PROJECTSTORAGE
     QCOMPARE(rootModelNode.type(), QmlDesigner::TypeName("QtQuick.Rectangle"));
     QCOMPARE(rootModelNode.metaInfo().majorVersion(), 2);
     QCOMPARE(rootModelNode.metaInfo().minorVersion(), 0);
     //QCOMPARE(rootModelNode.majorQtQuickVersion(), 2);
     QCOMPARE(rootModelNode.majorVersion(), 2);
+#endif
 }
 
 void tst_TestCore::testQtQuickControls2()