@dusted/anqst 1.5.1 → 1.7.0

package/dist/src/layout.js

@@ -41,8 +41,12 @@ function anqstSettingsFileName(widgetName) {
 function anqstSettingsRelativePath(widgetName) {
     return `./${exports.ANQST_ROOT_DIRNAME}/${anqstSettingsFileName(widgetName)}`;
 }
-function generatedFrontendDirName(widgetName) {
-    return `${widgetName}_Angular`;
+function generatedFrontendDirName(widgetName, target) {
+    if (target === "AngularService")
+        return `${widgetName}_Angular`;
+    if (target === "VanillaTS")
+        return `${widgetName}_VanillaTS`;
+    return `${widgetName}_VanillaJS`;
 }
 function generatedNodeExpressDirName(widgetName) {
     return `${widgetName}_anQst`;
@@ -56,7 +60,9 @@ function resolveGeneratedLayoutPaths(cwd, widgetName) {
     const designerPluginRoot = node_path_1.default.join(cppQtWidgetRoot, "designerPlugin");
     return {
         generatedRoot,
-        frontendRoot: node_path_1.default.join(generatedRoot, "frontend", generatedFrontendDirName(widgetName)),
+        angularFrontendRoot: node_path_1.default.join(generatedRoot, "frontend", generatedFrontendDirName(widgetName, "AngularService")),
+        vanillaTsFrontendRoot: node_path_1.default.join(generatedRoot, "frontend", generatedFrontendDirName(widgetName, "VanillaTS")),
+        vanillaJsFrontendRoot: node_path_1.default.join(generatedRoot, "frontend", generatedFrontendDirName(widgetName, "VanillaJS")),
         nodeExpressRoot: node_path_1.default.join(generatedRoot, "backend", "node", "express", generatedNodeExpressDirName(widgetName)),
         cppCmakeRoot: node_path_1.default.join(generatedRoot, "backend", "cpp", "cmake"),
         cppQtWidgetRoot,

package/dist/src/parser.js

@@ -24,6 +24,22 @@ function qNameToText(name) {
         return name.text;
     return `${qNameToText(name.left)}.${name.right.text}`;
 }
+function textToEntityName(text) {
+    const parts = text.split(".");
+    let current = typescript_1.default.factory.createIdentifier(parts[0] ?? text);
+    for (const part of parts.slice(1)) {
+        current = typescript_1.default.factory.createQualifiedName(current, typescript_1.default.factory.createIdentifier(part));
+    }
+    return current;
+}
+function textToExpressionName(text) {
+    const parts = text.split(".");
+    let current = typescript_1.default.factory.createIdentifier(parts[0] ?? text);
+    for (const part of parts.slice(1)) {
+        current = typescript_1.default.factory.createPropertyAccessExpression(current, typescript_1.default.factory.createIdentifier(part));
+    }
+    return current;
+}
 function collectReferencedTypeNames(node) {
     const refs = new Set();
     const visit = (n) => {
@@ -33,6 +49,9 @@ function collectReferencedTypeNames(node) {
         else if (typescript_1.default.isExpressionWithTypeArguments(n) && typescript_1.default.isIdentifier(n.expression)) {
             refs.add(n.expression.text);
         }
+        else if (typescript_1.default.isTypeQueryNode(n)) {
+            refs.add(qNameToText(n.exprName));
+        }
         typescript_1.default.forEachChild(n, visit);
     };
     visit(node);
@@ -294,10 +313,118 @@ function requiresLocalImportResolution(moduleName) {
         return false;
     return moduleName.includes("/");
 }
-function parseImportedTypeDecls(specFilePath, source) {
+function collectTopLevelTypeDecls(source) {
+    const out = new Map();
+    for (const stmt of source.statements) {
+        if ((typescript_1.default.isInterfaceDeclaration(stmt) || typescript_1.default.isTypeAliasDeclaration(stmt)) && stmt.name) {
+            out.set(stmt.name.text, stmt);
+        }
+    }
+    return out;
+}
+function collectReachableImportedTypeNames(topLevelDecls, rootNames) {
+    const queue = [...rootNames];
+    const seen = new Set();
+    const ordered = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (seen.has(current))
+            continue;
+        seen.add(current);
+        const node = topLevelDecls.get(current);
+        if (!node)
+            continue;
+        ordered.push(current);
+        const decl = {
+            referencedTypeNames: collectReferencedTypeNames(node)
+        };
+        for (const ref of decl.referencedTypeNames) {
+            if (topLevelDecls.has(ref) && !seen.has(ref)) {
+                queue.push(ref);
+            }
+        }
+    }
+    return ordered;
+}
+function allocateSyntheticImportedTypeName(sourceName, usedNames) {
+    const cleaned = sourceName
+        .replace(/[^A-Za-z0-9_]/g, "_")
+        .replace(/_+/g, "_")
+        .replace(/^_+|_+$/g, "");
+    const base = `AnQstImported_${cleaned || "Type"}`;
+    let candidate = base;
+    let i = 2;
+    while (usedNames.has(candidate)) {
+        candidate = `${base}_${i}`;
+        i += 1;
+    }
+    usedNames.add(candidate);
+    return candidate;
+}
+function rewriteImportedTypeDecl(importedSource, node, finalName, nameMap) {
+    const renamed = typescript_1.default.isInterfaceDeclaration(node)
+        ? typescript_1.default.factory.updateInterfaceDeclaration(node, node.modifiers, typescript_1.default.factory.createIdentifier(finalName), node.typeParameters, node.heritageClauses, node.members)
+        : typescript_1.default.factory.updateTypeAliasDeclaration(node, node.modifiers, typescript_1.default.factory.createIdentifier(finalName), node.typeParameters, node.type);
+    const transformed = typescript_1.default.transform(renamed, [(context) => {
+            const visitor = (child) => {
+                if (typescript_1.default.isTypeReferenceNode(child)) {
+                    const mapped = nameMap.get(qNameToText(child.typeName));
+                    if (mapped) {
+                        return typescript_1.default.factory.updateTypeReferenceNode(child, textToEntityName(mapped), child.typeArguments);
+                    }
+                }
+                else if (typescript_1.default.isExpressionWithTypeArguments(child)) {
+                    const exprText = typescript_1.default.isIdentifier(child.expression) || typescript_1.default.isPropertyAccessExpression(child.expression)
+                        ? child.expression.getText(importedSource)
+                        : null;
+                    const mapped = exprText ? nameMap.get(exprText) : null;
+                    if (mapped) {
+                        return typescript_1.default.factory.updateExpressionWithTypeArguments(child, textToExpressionName(mapped), child.typeArguments);
+                    }
+                }
+                else if (typescript_1.default.isTypeQueryNode(child)) {
+                    const mapped = nameMap.get(qNameToText(child.exprName));
+                    if (mapped) {
+                        return typescript_1.default.factory.updateTypeQueryNode(child, textToEntityName(mapped), child.typeArguments);
+                    }
+                }
+                return typescript_1.default.visitEachChild(child, visitor, context);
+            };
+            return (root) => typescript_1.default.visitNode(root, visitor);
+        }]);
+    const rewritten = transformed.transformed[0];
+    transformed.dispose();
+    const printer = typescript_1.default.createPrinter({ newLine: typescript_1.default.NewLineKind.LineFeed });
+    const rewrittenSource = typescript_1.default.createSourceFile("__anqst_imported_decl.ts", "", typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
+    const nodeText = printer.printNode(typescript_1.default.EmitHint.Unspecified, rewritten, rewrittenSource);
+    return {
+        name: finalName,
+        kind: typescript_1.default.isInterfaceDeclaration(rewritten) ? "interface" : "type",
+        nodeText,
+        referencedTypeNames: collectReferencedTypeNames(rewritten),
+        loc: locFromNode(importedSource, node)
+    };
+}
+function createImportedAliasDecl(aliasName, targetName, loc) {
+    const nodeText = `type ${aliasName} = ${targetName};`;
+    const source = typescript_1.default.createSourceFile("__anqst_import_alias.ts", nodeText, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
+    const stmt = source.statements.find(typescript_1.default.isTypeAliasDeclaration);
+    if (!stmt) {
+        throw new Error(`Unable to synthesize imported alias declaration for ${aliasName}.`);
+    }
+    return {
+        name: aliasName,
+        kind: "type",
+        nodeText,
+        referencedTypeNames: collectReferencedTypeNames(stmt),
+        loc
+    };
+}
+function parseImportedTypeDecls(specFilePath, source, reservedTypeNames = new Set()) {
     const importedTypeDecls = new Map();
     const importedTypeSymbols = new Set();
     const specImports = [];
+    const usedImportedNames = new Set(reservedTypeNames);
     for (const stmt of source.statements) {
         if (!typescript_1.default.isImportDeclaration(stmt) || !stmt.importClause || !typescript_1.default.isStringLiteral(stmt.moduleSpecifier))
             continue;
@@ -335,10 +462,38 @@ function parseImportedTypeDecls(specFilePath, source) {
         }
         const text = node_fs_1.default.readFileSync(resolved, "utf8");
         const importedSource = typescript_1.default.createSourceFile(resolved, text, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
-        for (const importedStmt of importedSource.statements) {
-            if (typescript_1.default.isInterfaceDeclaration(importedStmt) || typescript_1.default.isTypeAliasDeclaration(importedStmt)) {
-                const decl = parseTypeDecl(importedSource, importedStmt);
-                importedTypeDecls.set(decl.name, decl);
+        const topLevelDecls = collectTopLevelTypeDecls(importedSource);
+        const directAliasesBySourceName = new Map();
+        for (const namedImport of importModel.namedImports) {
+            if (!topLevelDecls.has(namedImport.importedName))
+                continue;
+            const aliases = directAliasesBySourceName.get(namedImport.importedName) ?? [];
+            aliases.push(namedImport.localName);
+            directAliasesBySourceName.set(namedImport.importedName, aliases);
+        }
+        const reachableSourceNames = collectReachableImportedTypeNames(topLevelDecls, directAliasesBySourceName.keys());
+        if (reachableSourceNames.length === 0)
+            continue;
+        const canonicalNameBySourceName = new Map();
+        for (const sourceName of reachableSourceNames) {
+            const directAliases = directAliasesBySourceName.get(sourceName);
+            if (directAliases && directAliases.length > 0) {
+                canonicalNameBySourceName.set(sourceName, directAliases[0]);
+                usedImportedNames.add(directAliases[0]);
+            }
+            else {
+                canonicalNameBySourceName.set(sourceName, allocateSyntheticImportedTypeName(sourceName, usedImportedNames));
+            }
+        }
+        for (const sourceName of reachableSourceNames) {
+            const node = topLevelDecls.get(sourceName);
+            const finalName = canonicalNameBySourceName.get(sourceName);
+            if (!node || !finalName)
+                continue;
+            importedTypeDecls.set(finalName, rewriteImportedTypeDecl(importedSource, node, finalName, canonicalNameBySourceName));
+            const directAliases = directAliasesBySourceName.get(sourceName) ?? [];
+            for (const alias of directAliases.slice(1)) {
+                importedTypeDecls.set(alias, createImportedAliasDecl(alias, finalName, locFromNode(importedSource, node)));
             }
         }
     }
@@ -398,7 +553,7 @@ function parseSpecFileAst(specFilePath) {
             namespaceTypeDecls.push(parseTypeDecl(source, stmt));
         }
     }
-    const importInfo = parseImportedTypeDecls(specFilePath, source);
+    const importInfo = parseImportedTypeDecls(specFilePath, source, new Set(namespaceTypeDecls.map((decl) => decl.name)));
     return {
         filePath: specFilePath,
         widgetName: ns.name.text,

package/dist/src/project.js

@@ -16,7 +16,7 @@ const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const errors_1 = require("./errors");
 const layout_1 = require("./layout");
-exports.DEFAULT_ANQST_GENERATE_TARGETS = ["QWidget", "AngularService", "node_express_ws"];
+exports.DEFAULT_ANQST_GENERATE_TARGETS = ["QWidget", "AngularService", "VanillaTS", "VanillaJS", "node_express_ws"];
 const ANQST_DSL_IMPORT_LINE = 'import type { AnQst } from "@dusted/anqst";';
 const ANQST_BUILD_HOOK = "npx anqst build";
 function readJsonFile(filePath) {
@@ -153,7 +153,7 @@ function updateTsConfig(cwd, widgetName) {
         ? {}
         : ensureObject(compilerOptions.paths, "Invalid tsconfig.json: expected object at 'compilerOptions.paths'.");
     compilerOptions.paths = pathsObject;
-    const generatedAliasPath = `AnQst/generated/frontend/${(0, layout_1.generatedFrontendDirName)(widgetName)}/*`;
+    const generatedAliasPath = `AnQst/generated/frontend/${(0, layout_1.generatedFrontendDirName)(widgetName, "AngularService")}/*`;
     const existingAlias = pathsObject["anqst-generated/*"];
     const aliasList = Array.isArray(existingAlias)
         ? existingAlias.filter((entry) => typeof entry === "string")
@@ -164,7 +164,7 @@ function updateTsConfig(cwd, widgetName) {
     pathsObject["anqst-generated/*"] = [...new Set(aliasList)];
     if (Array.isArray(tsConfig.include)) {
         const includeList = tsConfig.include.filter((entry) => typeof entry === "string");
-        const generatedTypesPattern = `AnQst/generated/frontend/${(0, layout_1.generatedFrontendDirName)(widgetName)}/**/*.d.ts`;
+        const generatedTypesPattern = `AnQst/generated/frontend/${(0, layout_1.generatedFrontendDirName)(widgetName, "AngularService")}/**/*.d.ts`;
         if (!includeList.includes(generatedTypesPattern)) {
             includeList.push(generatedTypesPattern);
         }

package/dist/src/verify.js

@@ -135,8 +135,10 @@ function collectReachableTypeNames(spec) {
     const allDecls = new Map();
     for (const d of spec.namespaceTypeDecls)
         allDecls.set(d.name, d);
-    for (const [name, d] of spec.importedTypeDecls)
-        allDecls.set(name, d);
+    for (const [name, d] of spec.importedTypeDecls) {
+        if (!allDecls.has(name))
+            allDecls.set(name, d);
+    }
     const queue = [];
     const seen = new Set();
     for (const d of spec.namespaceTypeDecls)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dusted/anqst",
-  "version": "1.5.1",
+  "version": "1.7.0",
   "description": "Opinionated backend generator for webapps.",
   "keywords": [
     "nodejs",

package/spec/AnQst-Spec-DSL.d.ts

@@ -31,13 +31,15 @@ export namespace AnQst {
     interface Service { }
 
     /**
-     * Declare service `InterfaceName` as development-mode capable transport service.
+     * Declare service `InterfaceName` as development-mode capable browser transport service.
      *
      * @remarks
      * - Extends the same method/property semantics as `AnQst.Service`.
-     * - Signals to the generator/runtime that this widget should emit dual-transport bridge support
+     * - Signals to the generator/runtime that this widget should emit dual-transport browser bridge support
      *   (Qt WebChannel + HTTP/WebSocket development bridge).
      * - Existing generated service APIs remain unchanged.
+     * - The name is historical. The capability applies to browser frontend profiles generally,
+     *   not only Angular-specific generation.
      *
      * @example
      * export interface UserService extends AnQst.AngularHTTPBaseServerClass { }
@@ -63,7 +65,7 @@ export namespace AnQst {
      * @example
      * // AnQst spec:
      * getUserById(userId: string): AnQst.Call<User>
-     * //Angular app:
+     * //Browser app:
      * const user: User = await this.userService.getUserById("abc");
     */
     interface Call<T, Config extends CallConfig = {}> { dummy: T; config?: Config }
@@ -89,7 +91,7 @@ export namespace AnQst {
      * @example
      * // AnQst spec:
      * getUsernameSubstring(from: number, to:number ): AnQst.Slot<string>
-     * //Angular app:
+     * //Browser app:
      * this.userService.onSlot.getUsername( provider );
      * //Parent:
      * auto currentFormUsername = userMgmt.getUsername();
@@ -111,7 +113,7 @@ export namespace AnQst {
      * @example
      * // AnQst spec:
      * complain(whine: string): AnQst.Emitter;
-     * //Angular app:
+     * //Browser app:
      * this.userService.complain("Why won't you LISTEN!");
     */
     interface Emitter { }
@@ -121,14 +123,14 @@ export namespace AnQst {
      * Declare reactive `PropertyName`:`OutputType` and set.`PropertyName`(arg: `OutputType`)
      * @remarks
      * - **Parent** -> Widget
-     * True Angular signal semantics (Property updates, signal emits, no return path, no registration requirement)
+     * True frontend reactive semantics (Property updates, accessor reflects latest value, no return path, no registration requirement)
      * - Flow:
      *   - Parent: Sets generated widget property `PropertyName`.
      *   - Widget: Service updates readonly property `PropertyName` and emits signal.
      * @example
      * // AnQst spec:
      * activeUsers: AnQst.Output<number>;
-     * //Angular app template:
+     * //Browser app:
      * <p>{{ userService.activeUsers() }}</p>
      * //Parent:
      * int users = userMgmt.activeUsers;
@@ -148,7 +150,7 @@ export namespace AnQst {
      * @example
      * // AnQst spec:
      * currentUsername: AnQst.Input<string>;
-     * //Angular app template:
+     * //Browser app:
      * <input type="text" placeholder="Your Name Here" (input)="userService.set.currentUsername(($event.target as HTMLInputElement).value)" />
      * //Parent:
      * QString userName = userMgmt.currentUsername;
@@ -160,15 +162,15 @@ export namespace AnQst {
      * Declare drop-target `PropertyName`:`PayloadType`
      * @remarks
      * - **Parent** -> Widget (framework-mediated)
-     * - True Angular signal semantics.
+     * - True frontend reactive semantics.
      * - Flow:
      *   - External: A Qt widget initiates a QDrag carrying QMimeData.
      *   - Parent: AnQstWebHostBase intercepts the drop via event filter on the
      *     embedded QWebEngineView's rendering surface.
      *   - Parent: QMimeData for the accepted format is deserialized from a JSON
      *     array of normalized AnQst wire items and forwarded through the bridge.
-     *   - Widget: Service updates signal `PropertyName` with the deserialized
-     *     payload and drop coordinates. Angular components react via effect() / template binding.
+     *   - Widget: Service updates the generated accessor for `PropertyName` with the deserialized
+     *     payload and drop coordinates. Browser application code reacts through the generated frontend API.
      * - MIME type is convention-derived: `application/anqst-dragdropevent_<ServiceName>-<TypeName>`.
      * - The source QWidget must serialize the generated AnQst wire payload as a
      *   JSON array under the same MIME type. Generated Qt widgets expose helper
@@ -178,11 +180,9 @@ export namespace AnQst {
      * @example
      * // AnQst spec:
      * trackDropped: AnQst.DropTarget<Track>;
-     * // Angular app:
-     * effect(() => {
-     *   const drop = this.service.trackDropped();
-     *   if (drop !== null) { console.log(drop.payload, drop.x, drop.y); }
-     * });
+     * // Browser app:
+     * const drop = frontend.services.DragService.trackDropped();
+     * if (drop !== null) { console.log(drop.payload, drop.x, drop.y); }
      */
     interface DropTarget<T> { dummy: T }
 
@@ -191,7 +191,7 @@ export namespace AnQst {
      * Declare hover-target `PropertyName`:`PayloadType`
      * @remarks
      * - **Parent** -> Widget (framework-mediated)
-     * - True Angular signal semantics.
+     * - True frontend reactive semantics.
      * - Flow:
      *   - External: A Qt widget initiates a QDrag carrying QMimeData.
      *   - Parent: AnQstWebHostBase intercepts drag-move events via event filter on the
@@ -199,8 +199,8 @@ export namespace AnQst {
      *   - Parent: Payload is deserialized once on DragEnter from a JSON array of
      *     normalized AnQst wire items; subsequent DragMove events forward only
      *     the updated position.
-     *   - Widget: Service updates signal `PropertyName` with the payload and current
-     *     coordinates. Signal becomes null on DragLeave.
+     *   - Widget: Service updates the generated accessor for `PropertyName` with the payload and current
+     *     coordinates. The accessor becomes null on DragLeave.
      * - Shares the same MIME type convention as DropTarget: `application/anqst-dragdropevent_<ServiceName>-<TypeName>`.
      * - A HoverTarget without a corresponding DropTarget means "show previews but reject the drop".
      * - Optional config supports throttle tuning:
@@ -217,11 +217,9 @@ export namespace AnQst {
      * trackHovering: AnQst.HoverTarget<Track, { maxRateHz: 10 }>;
      * // AnQst spec (no throttling):
      * trackHovering: AnQst.HoverTarget<Track, { maxRateHz: 0 }>;
-     * // Angular app:
-     * effect(() => {
-     *   const hover = this.service.trackHovering();
-     *   if (hover !== null) { highlight(document.elementFromPoint(hover.x, hover.y)); }
-     * });
+     * // Browser app:
+     * const hover = frontend.services.DragService.trackHovering();
+     * if (hover !== null) { highlight(document.elementFromPoint(hover.x, hover.y)); }
      */
 
     /**