@dusted/anqst 0.1.0 → 0.1.1

package/dist/src/emit.js

@@ -8,9 +8,11 @@ exports.writeGeneratedOutputs = writeGeneratedOutputs;
 exports.installTypeScriptOutputs = installTypeScriptOutputs;
 exports.installEmbeddedWebBundle = installEmbeddedWebBundle;
 exports.installQtIntegrationCMake = installQtIntegrationCMake;
+exports.installQtDesignerPluginCMake = installQtDesignerPluginCMake;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const typescript_1 = __importDefault(require("typescript"));
+const pngjs_1 = require("pngjs");
 function stripAnQstType(typeText) {
     return typeText
         .replace(/\bAnQst\.Type\.stringArray\b/g, "string[]")
@@ -158,6 +160,87 @@ function cppToVariantExpression(cppType, expr) {
     }
     return `QVariant::fromValue(${expr})`;
 }
+function splitTopLevelTemplateArgs(text) {
+    const args = [];
+    let start = 0;
+    let depth = 0;
+    for (let i = 0; i < text.length; i++) {
+        const ch = text[i];
+        if (ch === "<") {
+            depth++;
+            continue;
+        }
+        if (ch === ">") {
+            depth--;
+            continue;
+        }
+        if (ch === "," && depth === 0) {
+            args.push(text.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    const tail = text.slice(start).trim();
+    if (tail.length > 0) {
+        args.push(tail);
+    }
+    return args;
+}
+function templateTypeArgs(cppType, containerName) {
+    const trimmed = cppType.trim();
+    const prefix = `${containerName}<`;
+    if (!trimmed.startsWith(prefix) || !trimmed.endsWith(">")) {
+        return null;
+    }
+    const inner = trimmed.slice(prefix.length, -1).trim();
+    if (inner.length === 0)
+        return [];
+    return splitTopLevelTemplateArgs(inner);
+}
+function isNumericCppType(cppType) {
+    return [
+        "double",
+        "qint64",
+        "quint64",
+        "qint32",
+        "quint32",
+        "qint16",
+        "quint16",
+        "qint8",
+        "quint8",
+        "int8_t",
+        "uint8_t",
+        "int16_t",
+        "uint16_t",
+        "int32_t",
+        "uint32_t"
+    ].includes(cppType);
+}
+function designerPlaceholderCppExpression(cppType, memberName) {
+    const escapedMember = escapeCppStringLiteral(memberName);
+    const stringLiteral = `QStringLiteral("${escapedMember} value")`;
+    if (cppType === "QString")
+        return stringLiteral;
+    if (cppType === "bool")
+        return "true";
+    if (isNumericCppType(cppType))
+        return `static_cast<${cppType}>(1)`;
+    if (cppType === "QStringList")
+        return `QStringList{${stringLiteral}}`;
+    if (cppType === "QVariantMap") {
+        return `QVariantMap{{QStringLiteral("${escapedMember}"), QVariant(${stringLiteral})}}`;
+    }
+    const optionalArgs = templateTypeArgs(cppType, "std::optional");
+    if (optionalArgs && optionalArgs.length === 1) {
+        const inner = optionalArgs[0];
+        return `std::optional<${inner}>{${designerPlaceholderCppExpression(inner, memberName)}}`;
+    }
+    const listArgs = templateTypeArgs(cppType, "QList");
+    if (listArgs && listArgs.length === 1) {
+        const inner = listArgs[0];
+        return `QList<${inner}>{${designerPlaceholderCppExpression(inner, memberName)}}`;
+    }
+    return `${cppType}{}`;
+}
 function collectStructDecls(spec) {
     const out = new Map();
     for (const d of spec.namespaceTypeDecls)
@@ -746,7 +829,12 @@ function renderCppStub(spec, cppTypes) {
             const cppType = cppTypes.mapTypeText(member.payloadTypeText, [service.name, member.name, "Payload"]);
             const pascal = pascalCase(member.name);
             lines.push(`    if (service == QStringLiteral("${service.name}") && member == QStringLiteral("${member.name}")) {`);
-            lines.push(`        if (!m_${member.name}Handler) return QVariant();`);
+            lines.push(`        if (!m_${member.name}Handler) {`);
+            lines.push(`            if (property("anqstDesignerContext").toBool()) {`);
+            lines.push(`                return ${cppToVariantExpression(cppType, designerPlaceholderCppExpression(cppType, member.name))};`);
+            lines.push(`            }`);
+            lines.push(`            return QVariant();`);
+            lines.push(`        }`);
             for (let i = 0; i < member.parameters.length; i++) {
                 const p = member.parameters[i];
                 const pType = cppTypes.mapTypeText(p.typeText, [service.name, member.name, p.name]);
@@ -913,6 +1001,57 @@ function escapeXml(text) {
 function normalizeSlashes(value) {
     return value.split(node_path_1.default.sep).join("/");
 }
+function resolveActiveBuildStamp() {
+    const fromEnv = process.env.ANQST_BUILD_STAMP?.trim();
+    if (fromEnv && fromEnv.length > 0) {
+        return fromEnv;
+    }
+    const activePath = node_path_1.default.resolve(__dirname, "..", "..", ".anqstgen-version-active.json");
+    if (!node_fs_1.default.existsSync(activePath)) {
+        return "";
+    }
+    try {
+        const parsed = JSON.parse(node_fs_1.default.readFileSync(activePath, "utf8"));
+        if (typeof parsed.active === "string" && parsed.active.trim().length > 0) {
+            return parsed.active.trim();
+        }
+    }
+    catch {
+        return "";
+    }
+    return "";
+}
+function withBuildStamp(relativePath, content) {
+    const stamp = resolveActiveBuildStamp();
+    if (!stamp) {
+        return content;
+    }
+    const marker = `Built by AnQst ${stamp}`;
+    const rel = normalizeSlashes(relativePath);
+    const lower = rel.toLowerCase();
+    if (lower.endsWith(".json")) {
+        try {
+            const parsed = JSON.parse(content);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                const next = { "//": marker, ...parsed };
+                return `${JSON.stringify(next, null, 2)}\n`;
+            }
+        }
+        catch {
+            // If JSON parsing fails, fall through to plain comment prefix.
+        }
+    }
+    if (lower.endsWith(".qrc") || lower.endsWith(".xml") || lower.endsWith(".html")) {
+        return `<!-- ${marker} -->\n${content}`;
+    }
+    if (lower.endsWith(".cmake")) {
+        return `# ${marker}\n${content}`;
+    }
+    if (lower.endsWith(".h") || lower.endsWith(".cpp") || lower.endsWith(".ts") || lower.endsWith(".js") || lower.endsWith(".d.ts")) {
+        return `// ${marker}\n${content}`;
+    }
+    return `# ${marker}\n${content}`;
+}
 function renderEmbeddedQrc(widgetName, embeddedWebFiles) {
     const files = [...embeddedWebFiles].sort();
     const lines = [];
@@ -1231,6 +1370,11 @@ class WebSocketBridgeAdapter implements BridgeAdapter {
       }
       if (type === "hostError") {
         console.error("AnQst host error:", message["payload"]);
+        return;
+      }
+      if (type === "widgetReattached") {
+        document.body.textContent = "Widget Reattached";
+        this.socket.close();
       }
     });
   }
@@ -1240,12 +1384,22 @@ class WebSocketBridgeAdapter implements BridgeAdapter {
     if (!configResponse.ok) {
       throw new Error("AnQst host bootstrap missing: unable to read /anqst-dev-config.json");
     }
-    const config = (await configResponse.json()) as { wsUrl?: string };
-    if (!config.wsUrl) {
-      throw new Error("AnQst host bootstrap missing: wsUrl is unavailable.");
+    const config = (await configResponse.json()) as { wsUrl?: string; wsPath?: string };
+    let wsUrl = config.wsUrl;
+    if (!wsUrl && config.wsPath) {
+      const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+      wsUrl = protocol + "//" + window.location.host + config.wsPath;
+    }
+    if (!wsUrl) {
+      throw new Error("AnQst host bootstrap missing: wsUrl/wsPath is unavailable.");
+    }
+    if (wsUrl.startsWith("http://")) {
+      wsUrl = "ws://" + wsUrl.slice("http://".length);
+    } else if (wsUrl.startsWith("https://")) {
+      wsUrl = "wss://" + wsUrl.slice("https://".length);
     }
     return await new Promise<WebSocketBridgeAdapter>((resolve, reject) => {
-      const socket = new WebSocket(config.wsUrl!);
+      const socket = new WebSocket(wsUrl!);
       socket.addEventListener("open", () => resolve(new WebSocketBridgeAdapter(socket)));
       socket.addEventListener("error", () => reject(new Error("Failed to connect to AnQst WebSocket bridge.")));
     });
@@ -2224,7 +2378,7 @@ function writeGeneratedOutputs(cwd, outputs) {
     for (const [relPath, content] of Object.entries(outputs)) {
         const filePath = node_path_1.default.join(outputRoot, relPath);
         node_fs_1.default.mkdirSync(node_path_1.default.dirname(filePath), { recursive: true });
-        node_fs_1.default.writeFileSync(filePath, content, "utf8");
+        node_fs_1.default.writeFileSync(filePath, withBuildStamp(relPath, content), "utf8");
     }
 }
 function installTypeScriptOutputs(cwd) {
@@ -2393,7 +2547,7 @@ function installEmbeddedWebBundle(cwd, widgetName) {
     normalizeEmbeddedIndexHtml(node_path_1.default.join(cppLibraryWebRoot, "index.html"), cppLibraryWebRoot);
     const embeddedFiles = listFilesRecursively(cppLibraryWebRoot);
     const qrcPath = node_path_1.default.join(cppLibraryRoot, `${widgetName}.qrc`);
-    node_fs_1.default.writeFileSync(qrcPath, renderEmbeddedQrc(widgetName, embeddedFiles), "utf8");
+    node_fs_1.default.writeFileSync(qrcPath, withBuildStamp(`${widgetName}.qrc`, renderEmbeddedQrc(widgetName, embeddedFiles)), "utf8");
     return true;
 }
 function normalizeEmbeddedIndexHtml(indexPath, webRoot) {
@@ -2496,5 +2650,299 @@ target_link_libraries(${widgetTarget}
 function installQtIntegrationCMake(cwd, widgetName) {
     const integrationDir = node_path_1.default.join(cwd, "anqst-cmake");
     node_fs_1.default.mkdirSync(integrationDir, { recursive: true });
-    node_fs_1.default.writeFileSync(node_path_1.default.join(integrationDir, "CMakeLists.txt"), renderQtIntegrationCMake(widgetName), "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(integrationDir, "CMakeLists.txt"), withBuildStamp("anqst-cmake/CMakeLists.txt", renderQtIntegrationCMake(widgetName)), "utf8");
+}
+function normalizeIcoSize(dim) {
+    return dim === 0 ? 256 : dim;
+}
+function escapeCppStringLiteral(value) {
+    return value
+        .replace(/\\/g, "\\\\")
+        .replace(/"/g, '\\"')
+        .replace(/\r/g, "\\r")
+        .replace(/\n/g, "\\n");
+}
+function readDistFavicon(cwd) {
+    const distRoot = node_path_1.default.join(cwd, "dist");
+    if (!node_fs_1.default.existsSync(distRoot) || !node_fs_1.default.statSync(distRoot).isDirectory()) {
+        return null;
+    }
+    const stack = [distRoot];
+    while (stack.length > 0) {
+        const current = stack.shift();
+        const entries = node_fs_1.default.readdirSync(current, { withFileTypes: true })
+            .sort((a, b) => a.name.localeCompare(b.name));
+        for (const entry of entries) {
+            const fullPath = node_path_1.default.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(fullPath);
+                continue;
+            }
+            if (entry.isFile() && entry.name.toLowerCase() === "favicon.ico") {
+                return node_fs_1.default.readFileSync(fullPath);
+            }
+        }
+    }
+    return null;
+}
+function resolveFaviconIcoBuffer(cwd) {
+    const distFavicon = readDistFavicon(cwd);
+    if (distFavicon !== null) {
+        return distFavicon;
+    }
+    const fallbackFiles = [
+        node_path_1.default.join(cwd, "res", "favicon.ico"),
+        node_path_1.default.join(cwd, "src", "favicon.ico"),
+        node_path_1.default.join(cwd, "favicon.ico")
+    ];
+    for (const filePath of fallbackFiles) {
+        if (node_fs_1.default.existsSync(filePath) && node_fs_1.default.statSync(filePath).isFile()) {
+            return node_fs_1.default.readFileSync(filePath);
+        }
+    }
+    return null;
+}
+function decodeIcoBmpToPng(imageData) {
+    if (imageData.length < 40) {
+        throw new Error("ICO BMP frame too small.");
+    }
+    const headerSize = imageData.readUInt32LE(0);
+    if (headerSize < 40 || imageData.length < headerSize) {
+        throw new Error("ICO BMP frame has unsupported DIB header.");
+    }
+    const width = imageData.readInt32LE(4);
+    const heightTotal = imageData.readInt32LE(8);
+    const planes = imageData.readUInt16LE(12);
+    const bitCount = imageData.readUInt16LE(14);
+    const compression = imageData.readUInt32LE(16);
+    if (width <= 0 || heightTotal <= 0) {
+        throw new Error("ICO BMP frame has invalid dimensions.");
+    }
+    const height = Math.floor(heightTotal / 2);
+    if (height <= 0) {
+        throw new Error("ICO BMP frame has invalid mask height.");
+    }
+    if (planes !== 1 || bitCount !== 32 || compression !== 0) {
+        throw new Error("ICO BMP frame format unsupported; expected 32-bit BI_RGB.");
+    }
+    const pixelOffset = headerSize;
+    const rowBytes = width * 4;
+    const pixelBytes = rowBytes * height;
+    if (imageData.length < pixelOffset + pixelBytes) {
+        throw new Error("ICO BMP frame is truncated.");
+    }
+    const png = new pngjs_1.PNG({ width, height });
+    for (let y = 0; y < height; y += 1) {
+        const srcY = height - 1 - y;
+        const srcRow = pixelOffset + srcY * rowBytes;
+        const dstRow = y * rowBytes;
+        for (let x = 0; x < width; x += 1) {
+            const src = srcRow + x * 4;
+            const dst = dstRow + x * 4;
+            const b = imageData[src];
+            const g = imageData[src + 1];
+            const r = imageData[src + 2];
+            const a = imageData[src + 3];
+            png.data[dst] = r;
+            png.data[dst + 1] = g;
+            png.data[dst + 2] = b;
+            png.data[dst + 3] = a;
+        }
+    }
+    return pngjs_1.PNG.sync.write(png);
+}
+function convertIcoToPngBuffer(icoBytes) {
+    if (icoBytes.length < 6) {
+        throw new Error("favicon.ico is too small.");
+    }
+    const reserved = icoBytes.readUInt16LE(0);
+    const iconType = icoBytes.readUInt16LE(2);
+    const count = icoBytes.readUInt16LE(4);
+    if (reserved !== 0 || iconType !== 1 || count === 0) {
+        throw new Error("favicon.ico has invalid ICO header.");
+    }
+    if (icoBytes.length < 6 + count * 16) {
+        throw new Error("favicon.ico has truncated directory entries.");
+    }
+    const frames = [];
+    for (let i = 0; i < count; i += 1) {
+        const entryOffset = 6 + i * 16;
+        const width = normalizeIcoSize(icoBytes[entryOffset]);
+        const height = normalizeIcoSize(icoBytes[entryOffset + 1]);
+        const bytesInRes = icoBytes.readUInt32LE(entryOffset + 8);
+        const imageOffset = icoBytes.readUInt32LE(entryOffset + 12);
+        if (bytesInRes === 0)
+            continue;
+        if (imageOffset + bytesInRes > icoBytes.length)
+            continue;
+        frames.push({ width, height, bytesInRes, imageOffset });
+    }
+    if (frames.length === 0) {
+        throw new Error("favicon.ico contains no readable image frames.");
+    }
+    frames.sort((a, b) => {
+        const areaDiff = b.width * b.height - a.width * a.height;
+        if (areaDiff !== 0)
+            return areaDiff;
+        return b.bytesInRes - a.bytesInRes;
+    });
+    const pngSignature = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+    for (const frame of frames) {
+        const imageData = icoBytes.subarray(frame.imageOffset, frame.imageOffset + frame.bytesInRes);
+        if (imageData.subarray(0, 8).equals(pngSignature)) {
+            return Buffer.from(imageData);
+        }
+    }
+    return decodeIcoBmpToPng(icoBytes.subarray(frames[0].imageOffset, frames[0].imageOffset + frames[0].bytesInRes));
+}
+function renderDesignerPluginQrc() {
+    return `<RCC>
+  <qresource prefix="/anqstdesignerplugin">
+    <file>plugin-icon.png</file>
+  </qresource>
+</RCC>
+`;
+}
+function installDesignerPluginIconAssets(cwd, pluginDir) {
+    const iconTargetPath = node_path_1.default.join(pluginDir, "plugin-icon.png");
+    const qrcTargetPath = node_path_1.default.join(pluginDir, "designerplugin.qrc");
+    const icoBytes = resolveFaviconIcoBuffer(cwd);
+    if (icoBytes === null) {
+        if (node_fs_1.default.existsSync(iconTargetPath))
+            node_fs_1.default.rmSync(iconTargetPath, { force: true });
+        if (node_fs_1.default.existsSync(qrcTargetPath))
+            node_fs_1.default.rmSync(qrcTargetPath, { force: true });
+        return { hasIcon: false };
+    }
+    const pngBytes = convertIcoToPngBuffer(icoBytes);
+    node_fs_1.default.writeFileSync(iconTargetPath, pngBytes);
+    node_fs_1.default.writeFileSync(qrcTargetPath, renderDesignerPluginQrc(), "utf8");
+    return { hasIcon: true };
+}
+function renderQtDesignerPluginCpp(widgetName, widgetCategory, hasIcon) {
+    const pluginClass = `${widgetName}DesignerPlugin`;
+    const widgetClass = `${widgetName}::${widgetName}`;
+    const groupName = escapeCppStringLiteral(widgetCategory);
+    const iconExpression = hasIcon
+        ? 'QIcon(QStringLiteral(":/anqstdesignerplugin/plugin-icon.png"))'
+        : "QIcon()";
+    return `#include <QtUiPlugin/QDesignerCustomWidgetInterface>
+#include <QIcon>
+#include <QObject>
+#include <QString>
+#include <QWidget>
+#include "include/${widgetName}.h"
+
+class ${pluginClass} final : public QObject, public QDesignerCustomWidgetInterface {
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QDesignerCustomWidgetInterface")
+    Q_INTERFACES(QDesignerCustomWidgetInterface)
+
+public:
+    explicit ${pluginClass}(QObject* parent = nullptr) : QObject(parent) {}
+
+    QString name() const override { return QStringLiteral("${widgetClass}"); }
+    QString group() const override { return QStringLiteral("${groupName}"); }
+    QIcon icon() const override { return ${iconExpression}; }
+    QString toolTip() const override { return QStringLiteral("${widgetName} generated by AnQst."); }
+    QString whatsThis() const override { return QStringLiteral("${widgetName} generated by AnQst."); }
+    bool isContainer() const override { return false; }
+    QString includeFile() const override { return QStringLiteral("include/${widgetName}.h"); }
+    QWidget* createWidget(QWidget* parent) override {
+        auto* widget = new ${widgetClass}(parent);
+        widget->setProperty("anqstDesignerContext", true);
+        return widget;
+    }
+    bool isInitialized() const override { return true; }
+    void initialize(QDesignerFormEditorInterface*) override {}
+
+    QString domXml() const override {
+        return QStringLiteral(
+            "<ui language=\\"c++\\">\\n"
+            "  <widget class=\\"${widgetClass}\\" name=\\"${widgetName.toLowerCase()}\\">\\n"
+            "  </widget>\\n"
+            "</ui>\\n");
+    }
+};
+
+#include "${pluginClass}.moc"
+`;
+}
+function renderQtDesignerPluginCMake(widgetName, hasIcon) {
+    const widgetTarget = `${widgetName}Widget`;
+    const pluginTarget = `${widgetName}DesignerPlugin`;
+    const resourceLine = hasIcon ? "    \"${CMAKE_CURRENT_LIST_DIR}/designerplugin.qrc\"\n" : "";
+    return `cmake_minimum_required(VERSION 3.21)
+project(${pluginTarget} LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_AUTOUIC ON)
+set(CMAKE_AUTORCC ON)
+
+set(ANQST_WEBAPP_ROOT "\${CMAKE_CURRENT_LIST_DIR}/../..")
+set(ANQST_WIDGET_DIR "\${ANQST_WEBAPP_ROOT}/generated_output/${generatedCppLibraryDirName(widgetName)}")
+set(ANQST_WEBBASE_DIR "" CACHE PATH "Path to AnQstWebBase source directory")
+
+if(NOT EXISTS "\${ANQST_WIDGET_DIR}/CMakeLists.txt")
+    message(FATAL_ERROR "Missing generated widget CMake project at \${ANQST_WIDGET_DIR}. Run 'anqst build' first.")
+endif()
+
+if(NOT ANQST_WEBBASE_DIR)
+    foreach(candidate
+        "\${ANQST_WEBAPP_ROOT}/AnQstWidget/AnQstWebBase"
+        "\${ANQST_WEBAPP_ROOT}/../AnQstWidget/AnQstWebBase"
+        "\${ANQST_WEBAPP_ROOT}/../../AnQstWidget/AnQstWebBase"
+        "\${ANQST_WEBAPP_ROOT}/../../../AnQstWidget/AnQstWebBase")
+        if(EXISTS "\${candidate}/CMakeLists.txt")
+            set(ANQST_WEBBASE_DIR "\${candidate}")
+            break()
+        endif()
+    endforeach()
+endif()
+
+if(NOT ANQST_WEBBASE_DIR OR NOT EXISTS "\${ANQST_WEBBASE_DIR}/CMakeLists.txt")
+    message(FATAL_ERROR "Unable to locate AnQstWebBase sources. Set -DANQST_WEBBASE_DIR=<path/to/AnQstWidget/AnQstWebBase>.")
+endif()
+
+find_package(Qt5 REQUIRED COMPONENTS Core Widgets UiPlugin)
+
+set(ANQSTWEBBASE_BUILD_TESTS OFF CACHE BOOL "Build AnQstWebBase unit tests" FORCE)
+if(NOT TARGET anqstwebhostbase)
+    add_subdirectory("\${ANQST_WEBBASE_DIR}" "\${CMAKE_CURRENT_BINARY_DIR}/anqstwebbase")
+endif()
+
+if(NOT TARGET ${widgetTarget})
+    add_subdirectory("\${ANQST_WIDGET_DIR}" "\${CMAKE_CURRENT_BINARY_DIR}/generated-widget")
+endif()
+
+add_library(${pluginTarget} MODULE
+    "\${CMAKE_CURRENT_LIST_DIR}/${pluginTarget}.cpp"
+${resourceLine})
+target_include_directories(${pluginTarget}
+    PRIVATE
+        "\${ANQST_WIDGET_DIR}"
+        "\${ANQST_WIDGET_DIR}/include"
+)
+target_link_libraries(${pluginTarget}
+    PRIVATE
+        ${widgetTarget}
+        Qt5::Core
+        Qt5::Widgets
+        Qt5::UiPlugin
+)
+set_target_properties(${pluginTarget} PROPERTIES
+    PREFIX ""
+)
+`;
+}
+function installQtDesignerPluginCMake(cwd, widgetName, options = {}) {
+    const pluginDir = node_path_1.default.join(cwd, "anqst-cmake", "designerplugin");
+    node_fs_1.default.mkdirSync(pluginDir, { recursive: true });
+    const assets = installDesignerPluginIconAssets(cwd, pluginDir);
+    const pluginTarget = `${widgetName}DesignerPlugin`;
+    const widgetCategory = options.widgetCategory ?? "AnQst Widgets";
+    node_fs_1.default.writeFileSync(node_path_1.default.join(pluginDir, "CMakeLists.txt"), withBuildStamp("anqst-cmake/designerplugin/CMakeLists.txt", renderQtDesignerPluginCMake(widgetName, assets.hasIcon)), "utf8");
+    node_fs_1.default.writeFileSync(node_path_1.default.join(pluginDir, `${pluginTarget}.cpp`), withBuildStamp(`anqst-cmake/designerplugin/${pluginTarget}.cpp`, renderQtDesignerPluginCpp(widgetName, widgetCategory, assets.hasIcon)), "utf8");
 }