@qikdev/mcp 6.6.43 → 6.6.46

package/build/src/tools/interfaces.js

@@ -0,0 +1,821 @@
+import { ConfigManager } from "../config.js";
+// Tool to create interface with guided workflow
+export const createInterfaceTool = {
+    name: "create_interface",
+    description: "🎨 Create a new user interface with guided component selection and intelligent suggestions",
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "The title/name of the interface"
+            },
+            type: {
+                type: "string",
+                enum: ["website", "web-app", "portal", "blog", "ecommerce", "custom"],
+                description: "The type of interface to create"
+            },
+            description: {
+                type: "string",
+                description: "Brief description of what this interface should do (optional)"
+            },
+            features: {
+                type: "array",
+                items: { type: "string" },
+                description: "List of features needed (e.g., 'user login', 'contact form', 'blog posts')"
+            },
+            template: {
+                type: "string",
+                description: "Use a predefined template (optional)"
+            }
+        },
+        required: ["title", "type"],
+        additionalProperties: false
+    },
+};
+// Tool to add route to existing interface
+export const addInterfaceRouteTool = {
+    name: "add_interface_route",
+    description: "🛣️ Add a new route/page to an existing interface",
+    inputSchema: {
+        type: "object",
+        properties: {
+            interfaceId: {
+                type: "string",
+                description: "The ID of the interface to modify"
+            },
+            routeTitle: {
+                type: "string",
+                description: "The title of the new route/page"
+            },
+            routePath: {
+                type: "string",
+                description: "The URL path for the route (e.g., '/about', '/contact')"
+            },
+            routeName: {
+                type: "string",
+                description: "Internal name for the route (optional, will be generated from title)"
+            },
+            parentRoute: {
+                type: "string",
+                description: "Parent route name if this should be nested (optional)"
+            },
+            components: {
+                type: "array",
+                items: {
+                    type: "object",
+                    properties: {
+                        componentId: { type: "string" },
+                        data: { type: "object" }
+                    }
+                },
+                description: "Components to add to this route (optional)"
+            }
+        },
+        required: ["interfaceId", "routeTitle", "routePath"],
+        additionalProperties: false
+    },
+};
+// Tool to suggest interface templates
+export const suggestInterfaceTemplatesTool = {
+    name: "suggest_interface_templates",
+    description: "💡 Get template suggestions based on interface requirements",
+    inputSchema: {
+        type: "object",
+        properties: {
+            type: {
+                type: "string",
+                description: "Type of interface (website, web-app, etc.)"
+            },
+            purpose: {
+                type: "string",
+                description: "What the interface is for (business, portfolio, blog, etc.)"
+            },
+            features: {
+                type: "array",
+                items: { type: "string" },
+                description: "Required features"
+            }
+        },
+        required: ["type"],
+        additionalProperties: false
+    },
+};
+// Handler for creating interfaces
+export async function handleCreateInterface(args) {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadConfig();
+        if (!config) {
+            throw new Error('Qik MCP server not configured. Run setup first.');
+        }
+        // Get available components first
+        const componentsResponse = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/component/available`, {
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!componentsResponse.ok) {
+            throw new Error(`Failed to fetch available components: HTTP ${componentsResponse.status}`);
+        }
+        const availableComponents = await componentsResponse.json();
+        // Generate interface structure based on type and features
+        const interfaceStructure = generateInterfaceStructure(args, availableComponents);
+        // Create the interface using the existing create_content functionality
+        const createResponse = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/interface`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(interfaceStructure)
+        });
+        if (!createResponse.ok) {
+            const errorText = await createResponse.text();
+            throw new Error(`Failed to create interface: HTTP ${createResponse.status} - ${errorText}`);
+        }
+        const createdInterface = await createResponse.json();
+        // Format success response
+        let resultText = `🎨 **Interface "${args.title}" created successfully!**\n\n`;
+        resultText += `**ID:** ${createdInterface._id}\n`;
+        resultText += `**Type:** ${args.type}\n\n`;
+        if (interfaceStructure.routes && interfaceStructure.routes.length > 0) {
+            resultText += `**Routes created (${interfaceStructure.routes.length}):**\n`;
+            interfaceStructure.routes.forEach((route, index) => {
+                if (route.type === 'route') {
+                    resultText += `${index + 1}. ${route.title} (${route.path})\n`;
+                }
+                else if (route.type === 'folder' && route.routes) {
+                    resultText += `${index + 1}. 📁 ${route.title}\n`;
+                    route.routes.forEach((subRoute, subIndex) => {
+                        resultText += `   ${subIndex + 1}. ${subRoute.title} (${subRoute.path})\n`;
+                    });
+                }
+            });
+            resultText += '\n';
+        }
+        if (interfaceStructure.menus && interfaceStructure.menus.length > 0) {
+            resultText += `**Menus created:** ${interfaceStructure.menus.map((m) => m.title).join(', ')}\n\n`;
+        }
+        resultText += '🚀 Your interface is ready! You can now:\n';
+        resultText += '• Use `add_interface_route` to add more pages\n';
+        resultText += '• Use `update_content` to modify existing routes\n';
+        resultText += '• Use `get_component_details` to customize components\n';
+        return {
+            content: [{
+                    type: "text",
+                    text: resultText
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `❌ Failed to create interface: ${error.message}`
+                }]
+        };
+    }
+}
+// Handler for adding routes to interfaces
+export async function handleAddInterfaceRoute(args) {
+    try {
+        const configManager = new ConfigManager();
+        const config = await configManager.loadConfig();
+        if (!config) {
+            throw new Error('Qik MCP server not configured. Run setup first.');
+        }
+        // First, get the existing interface
+        const getResponse = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/interface/${args.interfaceId}`, {
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!getResponse.ok) {
+            throw new Error(`Failed to fetch interface: HTTP ${getResponse.status}`);
+        }
+        const existingInterface = await getResponse.json();
+        // Generate route name if not provided
+        const routeName = args.routeName || generateRouteName(args.routeTitle);
+        // Create new route structure
+        const newRoute = {
+            title: args.routeTitle,
+            path: args.routePath,
+            name: routeName,
+            type: 'route',
+            sections: [],
+            seo: {
+                title: args.routeTitle,
+                description: `${args.routeTitle} page`,
+                sitemapDisabled: false
+            }
+        };
+        // Add components if provided
+        if (args.components && args.components.length > 0) {
+            for (const comp of args.components) {
+                const section = {
+                    title: `Section with ${comp.componentId}`,
+                    uuid: generateUUID(),
+                    componentID: comp.componentId,
+                    componentVersion: 'latest',
+                    model: comp.data || {},
+                    slots: []
+                };
+                newRoute.sections.push(section);
+            }
+        }
+        else {
+            // Add a default Website Section with Basic Text
+            const defaultSection = {
+                title: "Website Section",
+                uuid: generateUUID(),
+                componentID: "647d02f56348660726cc552d", // Website Section component ID
+                componentVersion: "latest",
+                model: {
+                    outerClass: "v-wrap",
+                    innerClass: "h-wrap"
+                },
+                slots: [{
+                        title: "Content",
+                        key: "cells",
+                        sections: [{
+                                title: "Basic Text",
+                                uuid: generateUUID(),
+                                componentID: "62ba62fb63bd8436aae25c0c", // Basic Text component ID
+                                componentVersion: "latest",
+                                model: {
+                                    text: `<h2>${args.routeTitle}</h2><p>This is the ${args.routeTitle.toLowerCase()} page. Add your content here.</p>`
+                                },
+                                slots: []
+                            }]
+                    }]
+            };
+            newRoute.sections.push(defaultSection);
+        }
+        // Add route to the interface
+        if (!existingInterface.routes) {
+            existingInterface.routes = [];
+        }
+        // If parentRoute is specified, find it and add as nested route
+        if (args.parentRoute) {
+            const parentRoute = findRouteByName(existingInterface.routes, args.parentRoute);
+            if (parentRoute) {
+                if (!parentRoute.routes) {
+                    parentRoute.routes = [];
+                }
+                parentRoute.routes.push(newRoute);
+            }
+            else {
+                throw new Error(`Parent route "${args.parentRoute}" not found`);
+            }
+        }
+        else {
+            existingInterface.routes.push(newRoute);
+        }
+        // Update the interface
+        const updateResponse = await fetch(`${config.apiUrl || 'https://api.qik.dev'}/content/interface/${args.interfaceId}`, {
+            method: 'PUT',
+            headers: {
+                'Authorization': `Bearer ${config.accessToken}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(existingInterface)
+        });
+        if (!updateResponse.ok) {
+            const errorText = await updateResponse.text();
+            throw new Error(`Failed to update interface: HTTP ${updateResponse.status} - ${errorText}`);
+        }
+        return {
+            content: [{
+                    type: "text",
+                    text: `🛣️ **Route "${args.routeTitle}" added successfully!**\n\n` +
+                        `**Path:** ${args.routePath}\n` +
+                        `**Name:** ${routeName}\n` +
+                        `**Components:** ${newRoute.sections?.length || 0} sections added\n\n` +
+                        `The route is now available in your interface and can be accessed at ${args.routePath}.`
+                }]
+        };
+    }
+    catch (error) {
+        return {
+            content: [{
+                    type: "text",
+                    text: `❌ Failed to add route: ${error.message}`
+                }]
+        };
+    }
+}
+// Handler for suggesting interface templates
+export async function handleSuggestInterfaceTemplates(args) {
+    const templates = getInterfaceTemplates();
+    // Filter templates based on type and features
+    let suggestedTemplates = templates.filter(template => {
+        if (args.type && !template.name.toLowerCase().includes(args.type.toLowerCase())) {
+            return false;
+        }
+        if (args.features && args.features.length > 0) {
+            const templateFeatures = getTemplateFeatures(template);
+            const hasRequiredFeatures = args.features.some((feature) => templateFeatures.some(tf => tf.toLowerCase().includes(feature.toLowerCase())));
+            return hasRequiredFeatures;
+        }
+        return true;
+    });
+    if (suggestedTemplates.length === 0) {
+        suggestedTemplates = templates.slice(0, 3); // Show first 3 as fallback
+    }
+    let resultText = `💡 **Interface template suggestions:**\n\n`;
+    suggestedTemplates.forEach((template, index) => {
+        resultText += `**${index + 1}. ${template.title}**\n`;
+        resultText += `   Template: ${template.name}\n`;
+        resultText += `   Description: ${template.description}\n`;
+        resultText += `   Routes: ${template.routes.length} pages\n`;
+        const features = getTemplateFeatures(template);
+        if (features.length > 0) {
+            resultText += `   Features: ${features.join(', ')}\n`;
+        }
+        resultText += '\n';
+    });
+    resultText += '🎨 Use `create_interface` with the `template` parameter to use any of these templates.';
+    return {
+        content: [{
+                type: "text",
+                text: resultText
+            }]
+    };
+}
+// Helper functions
+function generateInterfaceStructure(args, availableComponents) {
+    const structure = {
+        title: args.title,
+        seo: {
+            title: args.title,
+            description: args.description || `${args.title} - Built with Qik`
+        },
+        menus: [],
+        services: [],
+        components: [],
+        styles: getDefaultStyles(),
+        header: { sections: [] },
+        footer: { sections: [] },
+        slots: [],
+        layout: "<div><header-slot /><route-slot /><footer-slot /></div>",
+        routes: []
+    };
+    // Use template if specified
+    if (args.template) {
+        const templates = getInterfaceTemplates();
+        const template = templates.find(t => t.name === args.template);
+        if (template) {
+            structure.routes = template.routes;
+            structure.menus = template.menus || [];
+            structure.header = template.header || { sections: [] };
+            structure.footer = template.footer || { sections: [] };
+            return structure;
+        }
+    }
+    // Generate routes based on type
+    switch (args.type) {
+        case 'website':
+            structure.routes = generateWebsiteRoutes(availableComponents);
+            structure.menus = generateWebsiteMenus();
+            break;
+        case 'web-app':
+            structure.routes = generateWebAppRoutes(availableComponents);
+            structure.menus = generateWebAppMenus();
+            break;
+        case 'portal':
+            structure.routes = generatePortalRoutes(availableComponents);
+            structure.menus = generatePortalMenus();
+            break;
+        case 'blog':
+            structure.routes = generateBlogRoutes(availableComponents);
+            structure.menus = generateBlogMenus();
+            break;
+        default:
+            structure.routes = generateBasicRoutes(availableComponents);
+            structure.menus = generateBasicMenus();
+    }
+    return structure;
+}
+function generateWebsiteRoutes(components) {
+    return [
+        {
+            title: "Home",
+            path: "/",
+            name: "home",
+            type: "route",
+            sections: [
+                {
+                    title: "Hero Section",
+                    uuid: generateUUID(),
+                    componentID: "647d02f56348660726cc552d",
+                    componentVersion: "latest",
+                    model: { outerClass: "v-wrap", innerClass: "h-wrap" },
+                    slots: [{
+                            title: "Content",
+                            key: "cells",
+                            sections: [{
+                                    title: "Welcome Text",
+                                    uuid: generateUUID(),
+                                    componentID: "62ba62fb63bd8436aae25c0c",
+                                    componentVersion: "latest",
+                                    model: {
+                                        text: "<h1>Welcome to Our Website</h1><p>This is a great place to introduce your business or organization.</p>"
+                                    },
+                                    slots: []
+                                }]
+                        }]
+                }
+            ]
+        },
+        {
+            title: "About",
+            path: "/about",
+            name: "about",
+            type: "route",
+            sections: [
+                {
+                    title: "About Section",
+                    uuid: generateUUID(),
+                    componentID: "647d02f56348660726cc552d",
+                    componentVersion: "latest",
+                    model: { outerClass: "v-wrap", innerClass: "h-wrap" },
+                    slots: [{
+                            title: "Content",
+                            key: "cells",
+                            sections: [{
+                                    title: "About Text",
+                                    uuid: generateUUID(),
+                                    componentID: "62ba62fb63bd8436aae25c0c",
+                                    componentVersion: "latest",
+                                    model: {
+                                        text: "<h2>About Us</h2><p>Tell your story here. What makes your organization unique?</p>"
+                                    },
+                                    slots: []
+                                }]
+                        }]
+                }
+            ]
+        },
+        {
+            title: "Contact",
+            path: "/contact",
+            name: "contact",
+            type: "route",
+            sections: [
+                {
+                    title: "Contact Section",
+                    uuid: generateUUID(),
+                    componentID: "647d02f56348660726cc552d",
+                    componentVersion: "latest",
+                    model: { outerClass: "v-wrap", innerClass: "h-wrap" },
+                    slots: [{
+                            title: "Content",
+                            key: "cells",
+                            sections: [{
+                                    title: "Contact Text",
+                                    uuid: generateUUID(),
+                                    componentID: "62ba62fb63bd8436aae25c0c",
+                                    componentVersion: "latest",
+                                    model: {
+                                        text: "<h2>Contact Us</h2><p>Get in touch with us. We'd love to hear from you!</p>"
+                                    },
+                                    slots: []
+                                }]
+                        }]
+                }
+            ]
+        }
+    ];
+}
+function generateWebAppRoutes(components) {
+    return [
+        {
+            title: "Dashboard",
+            path: "/",
+            name: "dashboard",
+            type: "route",
+            sections: [
+                {
+                    title: "Dashboard Section",
+                    uuid: generateUUID(),
+                    componentID: "647d02f56348660726cc552d",
+                    componentVersion: "latest",
+                    model: { outerClass: "v-wrap", innerClass: "h-wrap" },
+                    slots: [{
+                            title: "Content",
+                            key: "cells",
+                            sections: [{
+                                    title: "Dashboard Content",
+                                    uuid: generateUUID(),
+                                    componentID: "62ba62fb63bd8436aae25c0c",
+                                    componentVersion: "latest",
+                                    model: {
+                                        text: "<h1>Dashboard</h1><p>Welcome to your dashboard. Your app content goes here.</p>"
+                                    },
+                                    slots: []
+                                }]
+                        }]
+                }
+            ]
+        },
+        {
+            title: "User",
+            path: "/user",
+            name: "user",
+            type: "folder",
+            routes: [
+                {
+                    title: "Login",
+                    path: "/login",
+                    name: "login",
+                    type: "route",
+                    sections: [
+                        {
+                            title: "Login Section",
+                            uuid: generateUUID(),
+                            componentID: "647d02f56348660726cc552d",
+                            componentVersion: "latest",
+                            model: { outerClass: "v-wrap", innerClass: "h-wrap" },
+                            slots: [{
+                                    title: "Content",
+                                    key: "cells",
+                                    sections: [{
+                                            title: "Login Form",
+                                            uuid: generateUUID(),
+                                            componentID: "62ba62fb63bd8436aae25c0c",
+                                            componentVersion: "latest",
+                                            model: {
+                                                text: "<h2>Login</h2><p>Login form will be added here.</p>"
+                                            },
+                                            slots: []
+                                        }]
+                                }]
+                        }
+                    ]
+                },
+                {
+                    title: "Profile",
+                    path: "/profile",
+                    name: "profile",
+                    type: "route",
+                    sections: [
+                        {
+                            title: "Profile Section",
+                            uuid: generateUUID(),
+                            componentID: "647d02f56348660726cc552d",
+                            componentVersion: "latest",
+                            model: { outerClass: "v-wrap", innerClass: "h-wrap" },
+                            slots: [{
+                                    title: "Content",
+                                    key: "cells",
+                                    sections: [{
+                                            title: "Profile Content",
+                                            uuid: generateUUID(),
+                                            componentID: "62ba62fb63bd8436aae25c0c",
+                                            componentVersion: "latest",
+                                            model: {
+                                                text: "<h2>User Profile</h2><p>User profile information goes here.</p>"
+                                            },
+                                            slots: []
+                                        }]
+                                }]
+                        }
+                    ]
+                }
+            ]
+        }
+    ];
+}
+function generatePortalRoutes(components) {
+    return generateWebAppRoutes(components); // Similar to web app for now
+}
+function generateBlogRoutes(components) {
+    return [
+        {
+            title: "Home",
+            path: "/",
+            name: "home",
+            type: "route",
+            sections: [
+                {
+                    title: "Blog Home",
+                    uuid: generateUUID(),
+                    componentID: "647d02f56348660726cc552d",
+                    componentVersion: "latest",
+                    model: { outerClass: "v-wrap", innerClass: "h-wrap" },
+                    slots: [{
+                            title: "Content",
+                            key: "cells",
+                            sections: [{
+                                    title: "Blog Intro",
+                                    uuid: generateUUID(),
+                                    componentID: "62ba62fb63bd8436aae25c0c",
+                                    componentVersion: "latest",
+                                    model: {
+                                        text: "<h1>My Blog</h1><p>Welcome to my blog. Here you'll find my latest thoughts and articles.</p>"
+                                    },
+                                    slots: []
+                                }]
+                        }]
+                }
+            ]
+        },
+        {
+            title: "About",
+            path: "/about",
+            name: "about",
+            type: "route",
+            sections: [
+                {
+                    title: "About Section",
+                    uuid: generateUUID(),
+                    componentID: "647d02f56348660726cc552d",
+                    componentVersion: "latest",
+                    model: { outerClass: "v-wrap", innerClass: "h-wrap" },
+                    slots: [{
+                            title: "Content",
+                            key: "cells",
+                            sections: [{
+                                    title: "About Text",
+                                    uuid: generateUUID(),
+                                    componentID: "62ba62fb63bd8436aae25c0c",
+                                    componentVersion: "latest",
+                                    model: {
+                                        text: "<h2>About Me</h2><p>Learn more about the author of this blog.</p>"
+                                    },
+                                    slots: []
+                                }]
+                        }]
+                }
+            ]
+        }
+    ];
+}
+function generateBasicRoutes(components) {
+    return [
+        {
+            title: "Home",
+            path: "/",
+            name: "home",
+            type: "route",
+            sections: [
+                {
+                    title: "Home Section",
+                    uuid: generateUUID(),
+                    componentID: "647d02f56348660726cc552d",
+                    componentVersion: "latest",
+                    model: { outerClass: "v-wrap", innerClass: "h-wrap" },
+                    slots: [{
+                            title: "Content",
+                            key: "cells",
+                            sections: [{
+                                    title: "Welcome Text",
+                                    uuid: generateUUID(),
+                                    componentID: "62ba62fb63bd8436aae25c0c",
+                                    componentVersion: "latest",
+                                    model: {
+                                        text: "<h1>Welcome</h1><p>This is your new interface. Start customizing it!</p>"
+                                    },
+                                    slots: []
+                                }]
+                        }]
+                }
+            ]
+        }
+    ];
+}
+function generateWebsiteMenus() {
+    return [
+        {
+            title: "Primary Menu",
+            name: "primaryMenu",
+            items: [
+                { title: "Home", type: "route", route: "home" },
+                { title: "About", type: "route", route: "about" },
+                { title: "Contact", type: "route", route: "contact" }
+            ]
+        }
+    ];
+}
+function generateWebAppMenus() {
+    return [
+        {
+            title: "Primary Menu",
+            name: "primaryMenu",
+            items: [
+                { title: "Dashboard", type: "route", route: "dashboard" },
+                { title: "Login", type: "route", route: "login" },
+                { title: "Profile", type: "route", route: "profile" }
+            ]
+        }
+    ];
+}
+function generatePortalMenus() {
+    return generateWebAppMenus(); // Similar to web app
+}
+function generateBlogMenus() {
+    return [
+        {
+            title: "Primary Menu",
+            name: "primaryMenu",
+            items: [
+                { title: "Home", type: "route", route: "home" },
+                { title: "About", type: "route", route: "about" }
+            ]
+        }
+    ];
+}
+function generateBasicMenus() {
+    return [
+        {
+            title: "Primary Menu",
+            name: "primaryMenu",
+            items: [
+                { title: "Home", type: "route", route: "home" }
+            ]
+        }
+    ];
+}
+function getDefaultStyles() {
+    return {
+        pre: ":root {\n    --primary: #007bff;\n    --text: #333;\n    --bg: #fff;\n}",
+        post: "body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; }",
+        includes: [],
+        themes: []
+    };
+}
+function getInterfaceTemplates() {
+    return [
+        {
+            name: "basic-website",
+            title: "Basic Website",
+            description: "Simple website with Home, About, and Contact pages",
+            routes: generateWebsiteRoutes([]),
+            menus: generateWebsiteMenus()
+        },
+        {
+            name: "user-portal",
+            title: "User Portal",
+            description: "Web application with user authentication and dashboard",
+            routes: generateWebAppRoutes([]),
+            menus: generateWebAppMenus()
+        },
+        {
+            name: "blog-site",
+            title: "Blog Site",
+            description: "Blog website with article listing and detail pages",
+            routes: generateBlogRoutes([]),
+            menus: generateBlogMenus()
+        }
+    ];
+}
+function getTemplateFeatures(template) {
+    const features = [];
+    // Analyze routes to determine features
+    const routeNames = template.routes.map(r => r.name?.toLowerCase() || r.title.toLowerCase());
+    if (routeNames.includes('login') || routeNames.includes('signin')) {
+        features.push('User Authentication');
+    }
+    if (routeNames.includes('profile') || routeNames.includes('account')) {
+        features.push('User Profiles');
+    }
+    if (routeNames.includes('dashboard')) {
+        features.push('Dashboard');
+    }
+    if (routeNames.includes('blog') || routeNames.includes('articles')) {
+        features.push('Blog/Articles');
+    }
+    if (routeNames.includes('contact')) {
+        features.push('Contact Page');
+    }
+    if (template.menus && template.menus.length > 0) {
+        features.push('Navigation Menu');
+    }
+    return features;
+}
+function generateRouteName(title) {
+    return title.toLowerCase()
+        .replace(/[^a-z0-9\s]/g, '')
+        .replace(/\s+/g, '')
+        .substring(0, 20);
+}
+function generateUUID() {
+    return Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15);
+}
+function findRouteByName(routes, name) {
+    for (const route of routes) {
+        if (route.name === name) {
+            return route;
+        }
+        if (route.routes) {
+            const found = findRouteByName(route.routes, name);
+            if (found)
+                return found;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=interfaces.js.map