@sampleapp.ai/sdk 1.0.35 → 1.0.37

package/dist/components/guardian/utils.js

@@ -1,88 +0,0 @@
-import { FrameworkLabel, } from "./types/ide-types";
-/**
- * Creates sandbox URL configs for preloading from a framework's urlsToPreload.
- * Only includes URLs that need VM preloading (useVm: true).
- * Uses the same sandboxUid for all configs since caching is done by sandboxUid + browserUrl.
- */
-export function createSandboxUrlConfigs(sandboxUid, urlsToPreload) {
-    if (!urlsToPreload) {
-        return [];
-    }
-    return urlsToPreload
-        .filter((config) => config.useVm)
-        .map((config) => ({
-        sandboxUid: config.suffix ? `${sandboxUid}-${config.suffix}` : sandboxUid,
-        browserUrl: config.browserUrl,
-        useVm: config.useVm,
-    }));
-}
-/**
- * Builds a nested GuardianConfig from use cases with nested frameworks.
- * Returns a structure where config[useCaseId].frameworks[frameworkKey] gives you the full config.
- *
- * @example
- * const config = buildGuardianConfig(USE_CASES, options);
- * // Access via: config["full-stack-auth"].frameworks["nextjs"]
- */
-export function buildGuardianConfig(useCases, options) {
-    var _a;
-    const { playgroundUid, playgroundLogo, frameworkLabels, variant } = options;
-    const result = {};
-    for (const uc of useCases) {
-        // Build the use case config
-        const useCaseConfig = {
-            id: uc.id,
-            name: uc.name,
-            description: uc.description,
-            themeColor: uc.themeColor,
-            hasPreview: uc.hasPreview,
-            frameworks: {},
-        };
-        // Compute frameworkOptions from ALL frameworks in this use case
-        const frameworkOptions = uc.frameworks.map((fw) => {
-            var _a, _b;
-            return ({
-                label: (_b = (_a = (frameworkLabels && frameworkLabels[fw.key])) !== null && _a !== void 0 ? _a : FrameworkLabel[fw.key]) !== null && _b !== void 0 ? _b : fw.key,
-                value: fw.key,
-            });
-        });
-        // Add each framework to the use case
-        for (const fw of uc.frameworks) {
-            useCaseConfig.frameworks[fw.key] = {
-                frameworkKey: fw.key,
-                name: uc.name,
-                description: uc.description,
-                demoOptions: [], // Will be populated below
-                frameworkOptions,
-                firstFrameworkByUseCase: undefined, // Will be passed from guardian-playground
-                currentFramework: fw.key,
-                CustomConsole: fw.CustomConsole,
-                GuideView: fw.GuideView,
-                playgroundUid,
-                playgroundLogo,
-                browserUrl: fw.browserUrl,
-                useVm: fw.useVm,
-                sandboxUid: fw.sandboxUid,
-                codeZipFile: fw.codeZipFile,
-                completeCodeZipFile: fw.completeCodeZipFile,
-                consoleUrlConfigs: createSandboxUrlConfigs(fw.sandboxUid, fw.urlsToPreload),
-                themeColor: (_a = fw.themeColor) !== null && _a !== void 0 ? _a : uc.themeColor,
-                variant,
-                hasPreview: uc.hasPreview,
-            };
-        }
-        result[uc.id] = useCaseConfig;
-    }
-    // Now populate demoOptions for all frameworks (they all get the same list)
-    const demoOptions = useCases.map((uc) => ({
-        label: uc.name,
-        value: uc.id, // Use the use case ID as the value
-    }));
-    // Update all framework configs with the complete demoOptions
-    for (const useCaseConfig of Object.values(result)) {
-        for (const frameworkConfig of Object.values(useCaseConfig.frameworks)) {
-            frameworkConfig.demoOptions = demoOptions;
-        }
-    }
-    return result;
-}

package/dist/components/guardian/zip-to-codebase.js

@@ -1,246 +0,0 @@
-import JSZip from "jszip";
-import { filePathToCodeLanguage } from "./types/ide-types";
-/**
- * Converts a zip file to UpdateContainerCodebaseType (flat Record structure)
- * @param zipData - The zip file as Blob, File, ArrayBuffer, or Uint8Array
- * @returns Promise<UpdateContainerCodebaseType> - A flat record of file paths to CodeOutput
- */
-export async function zipToCodebase(zipData) {
-    try {
-        const zip = await JSZip.loadAsync(zipData);
-        const codebase = {};
-        // Get all file paths (excluding directories and __MACOSX)
-        const filePaths = Object.keys(zip.files).filter((path) => {
-            const file = zip.files[path];
-            return (!file.dir &&
-                !path.includes("__MACOSX") &&
-                !path.includes("__pycache__") &&
-                !path.includes(".DS_Store") &&
-                !path.startsWith("._") &&
-                !path.includes("/._"));
-        });
-        // Find common root folder prefix
-        let commonPrefix = "";
-        if (filePaths.length > 0) {
-            // Get the first path's root folder
-            const firstPath = filePaths[0];
-            const firstSlashIndex = firstPath.indexOf("/");
-            if (firstSlashIndex > 0) {
-                const potentialPrefix = firstPath.substring(0, firstSlashIndex + 1);
-                // Check if all paths start with this prefix
-                const allHavePrefix = filePaths.every((path) => path.startsWith(potentialPrefix));
-                if (allHavePrefix) {
-                    commonPrefix = potentialPrefix;
-                }
-            }
-        }
-        // Process all files in the zip
-        const filePromises = [];
-        for (const relativePath of filePaths) {
-            const file = zip.files[relativePath];
-            // Get file content as text
-            const contentPromise = file
-                .async("string")
-                .then((content) => {
-                // Strip common prefix from the file path
-                let filePath = relativePath;
-                if (commonPrefix && filePath.startsWith(commonPrefix)) {
-                    filePath = filePath.substring(commonPrefix.length);
-                }
-                const fileName = filePath.split("/").pop() || filePath;
-                const codeLanguage = filePathToCodeLanguage(filePath);
-                codebase[filePath] = {
-                    response_type: "CodeOutput",
-                    file_path: filePath,
-                    code_file_name: fileName,
-                    code_language: codeLanguage,
-                    dependencies_to_install: [],
-                    framework: null,
-                    full_code: content,
-                };
-            })
-                .catch((error) => {
-                // If file can't be read as text, skip it or handle binary files
-                console.warn(`Could not read file ${relativePath} as text:`, error);
-            });
-            filePromises.push(contentPromise);
-        }
-        // Wait for all files to be processed
-        await Promise.all(filePromises);
-        return codebase;
-    }
-    catch (error) {
-        console.error("Error parsing zip file:", error);
-        throw new Error(`Failed to parse zip file: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Converts a zip file to UpdateContainerCodebaseType with binary file support
- * Binary files will have their content as base64 encoded strings
- * @param zipData - The zip file as Blob, File, ArrayBuffer, or Uint8Array
- * @returns Promise<UpdateContainerCodebaseType> - A flat record of file paths to CodeOutput
- */
-export async function zipToCodebaseWithBinary(zipData) {
-    try {
-        const zip = await JSZip.loadAsync(zipData);
-        const codebase = {};
-        // Get all file paths (excluding directories and __MACOSX)
-        const filePaths = Object.keys(zip.files).filter((path) => {
-            const file = zip.files[path];
-            return (!file.dir &&
-                !path.includes("__MACOSX") &&
-                !path.includes("__pycache__") &&
-                !path.includes(".DS_Store") &&
-                !path.startsWith("._") &&
-                !path.includes("/._"));
-        });
-        // Find common root folder prefix
-        let commonPrefix = "";
-        if (filePaths.length > 0) {
-            // Get the first path's root folder
-            const firstPath = filePaths[0];
-            const firstSlashIndex = firstPath.indexOf("/");
-            if (firstSlashIndex > 0) {
-                const potentialPrefix = firstPath.substring(0, firstSlashIndex + 1);
-                // Check if all paths start with this prefix
-                const allHavePrefix = filePaths.every((path) => path.startsWith(potentialPrefix));
-                if (allHavePrefix) {
-                    commonPrefix = potentialPrefix;
-                }
-            }
-        }
-        // Process all files in the zip
-        const filePromises = [];
-        for (const relativePath of filePaths) {
-            const file = zip.files[relativePath];
-            // Try to read as text first, fallback to base64 for binary files
-            const contentPromise = (async () => {
-                let content;
-                try {
-                    // Try reading as text
-                    content = await file.async("string");
-                }
-                catch (_a) {
-                    // If that fails, read as base64
-                    const binary = await file.async("base64");
-                    content = binary;
-                }
-                // Strip common prefix from the file path
-                let filePath = relativePath;
-                if (commonPrefix && filePath.startsWith(commonPrefix)) {
-                    filePath = filePath.substring(commonPrefix.length);
-                }
-                const fileName = filePath.split("/").pop() || filePath;
-                const codeLanguage = filePathToCodeLanguage(filePath);
-                codebase[filePath] = {
-                    response_type: "CodeOutput",
-                    file_path: filePath,
-                    code_file_name: fileName,
-                    code_language: codeLanguage,
-                    dependencies_to_install: [],
-                    framework: null,
-                    full_code: content,
-                };
-            })();
-            filePromises.push(contentPromise);
-        }
-        // Wait for all files to be processed
-        await Promise.all(filePromises);
-        return codebase;
-    }
-    catch (error) {
-        console.error("Error parsing zip file:", error);
-        throw new Error(`Failed to parse zip file: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Reads a zip file from a path and converts it to UpdateContainerCodebaseType
- * @param filePath - The path to the zip file (e.g., "/public/guardian/launchdarkly-guardian/code-1.zip" or "/guardian/launchdarkly-guardian/code-1.zip")
- * @returns Promise<UpdateContainerCodebaseType> - A flat record of file paths to CodeOutput
- */
-export async function zipPathToCodebase(filePath) {
-    try {
-        // Normalize the path - remove /public prefix if present (Next.js serves public folder from root)
-        let normalizedPath = filePath;
-        if (normalizedPath.startsWith("/public/")) {
-            normalizedPath = normalizedPath.slice("/public".length);
-        }
-        // Ensure path starts with /
-        if (!normalizedPath.startsWith("/")) {
-            normalizedPath = "/" + normalizedPath;
-        }
-        // Build the URL - handle both client-side (relative) and server-side (absolute) cases
-        let url;
-        if (typeof window !== "undefined") {
-            // Client-side: use relative URL
-            url = normalizedPath;
-        }
-        else {
-            // Server-side: need absolute URL
-            // Try to get base URL from environment or use a default
-            const baseUrl = process.env.NEXT_PUBLIC_BASE_URL ||
-                process.env.VERCEL_URL ||
-                "http://localhost:3000";
-            url = `${baseUrl}${normalizedPath}`;
-        }
-        // Fetch the file from the public folder
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch zip file from ${url}: ${response.status} ${response.statusText}`);
-        }
-        // Get the file as a blob
-        const blob = await response.blob();
-        // Convert to UpdateContainerCodebaseType using zipToCodebase
-        return await zipToCodebase(blob);
-    }
-    catch (error) {
-        console.error(`Error reading zip file from path ${filePath}:`, error);
-        throw new Error(`Failed to read zip file from path: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Reads a zip file from a path and converts it to UpdateContainerCodebaseType with binary file support
- * Binary files will have their content as base64 encoded strings
- * @param filePath - The path to the zip file (e.g., "/public/guardian/launchdarkly-guardian/code-1.zip" or "/guardian/launchdarkly-guardian/code-1.zip")
- * @returns Promise<UpdateContainerCodebaseType> - A flat record of file paths to CodeOutput
- */
-export async function zipPathToCodebaseWithBinary(filePath) {
-    try {
-        // Normalize the path - remove /public prefix if present (Next.js serves public folder from root)
-        let normalizedPath = filePath;
-        if (normalizedPath.startsWith("/public/")) {
-            normalizedPath = normalizedPath.slice("/public".length);
-        }
-        // Ensure path starts with /
-        if (!normalizedPath.startsWith("/")) {
-            normalizedPath = "/" + normalizedPath;
-        }
-        // Build the URL - handle both client-side (relative) and server-side (absolute) cases
-        let url;
-        if (typeof window !== "undefined") {
-            // Client-side: use relative URL
-            url = normalizedPath;
-        }
-        else {
-            // Server-side: need absolute URL
-            // Try to get base URL from environment or use a default
-            const baseUrl = process.env.NEXT_PUBLIC_BASE_URL ||
-                process.env.VERCEL_URL ||
-                "http://localhost:3000";
-            url = `${baseUrl}${normalizedPath}`;
-        }
-        // Fetch the file from the public folder
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch zip file from ${url}: ${response.status} ${response.statusText}`);
-        }
-        // Get the file as a blob
-        const blob = await response.blob();
-        // Convert to UpdateContainerCodebaseType using zipToCodebaseWithBinary
-        return await zipToCodebaseWithBinary(blob);
-    }
-    catch (error) {
-        console.error(`Error reading zip file from path ${filePath}:`, error);
-        throw new Error(`Failed to read zip file from path: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}

package/dist/components/guardian/zip-to-filetree.js

@@ -1,284 +0,0 @@
-import JSZip from "jszip";
-import { CodeLanguage, filePathToCodeLanguage, } from "./types/ide-types";
-/**
- * Converts a zip file to a FileTreeNode structure
- * @param zipData - The zip file as Blob, File, ArrayBuffer, or Uint8Array
- * @returns Promise<FileTreeNode> - The root node of the file tree
- */
-export async function zipToFileTree(zipData) {
-    try {
-        const zip = await JSZip.loadAsync(zipData);
-        // Create root node
-        const root = {
-            name: "root",
-            children: {},
-            type: "folder",
-            metadata: {
-                response_type: "CodeOutput",
-                file_path: "",
-                code_file_name: "",
-                code_language: CodeLanguage.TEXT,
-                dependencies_to_install: [],
-                framework: null,
-                full_code: "",
-            },
-        };
-        // Process all files in the zip
-        const filePromises = [];
-        for (const relativePath in zip.files) {
-            const file = zip.files[relativePath];
-            // Skip directories (they're handled by the path structure)
-            if (file.dir) {
-                continue;
-            }
-            // Get file content as text
-            const contentPromise = file
-                .async("string")
-                .then((content) => {
-                // Build the tree structure from the path
-                const pathParts = relativePath.split("/").filter(Boolean);
-                let currentNode = root;
-                // Navigate/create folder structure
-                for (let i = 0; i < pathParts.length - 1; i++) {
-                    const part = pathParts[i];
-                    if (!currentNode.children[part]) {
-                        currentNode.children[part] = {
-                            name: part,
-                            children: {},
-                            type: "folder",
-                            metadata: {
-                                response_type: "CodeOutput",
-                                file_path: pathParts.slice(0, i + 1).join("/"),
-                                code_file_name: part,
-                                code_language: CodeLanguage.TEXT,
-                                dependencies_to_install: [],
-                                framework: null,
-                                full_code: "",
-                            },
-                        };
-                    }
-                    currentNode = currentNode.children[part];
-                }
-                // Add the file
-                const fileName = pathParts[pathParts.length - 1];
-                const filePath = relativePath;
-                const codeLanguage = filePathToCodeLanguage(filePath);
-                currentNode.children[fileName] = {
-                    name: fileName,
-                    children: {},
-                    type: "file",
-                    metadata: {
-                        response_type: "CodeOutput",
-                        file_path: filePath,
-                        code_file_name: fileName,
-                        code_language: codeLanguage,
-                        dependencies_to_install: [],
-                        framework: null,
-                        full_code: content,
-                    },
-                };
-            })
-                .catch((error) => {
-                // If file can't be read as text, skip it or handle binary files
-                console.warn(`Could not read file ${relativePath} as text:`, error);
-            });
-            filePromises.push(contentPromise);
-        }
-        // Wait for all files to be processed
-        await Promise.all(filePromises);
-        return root;
-    }
-    catch (error) {
-        console.error("Error parsing zip file:", error);
-        throw new Error(`Failed to parse zip file: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Reads a zip file from a path and converts it to a FileTreeNode structure
- * @param filePath - The path to the zip file (e.g., "/public/code/guardian/launchdarkly-guardian/code-1.zip" or "/code/guardian/launchdarkly-guardian/code-1.zip")
- * @returns Promise<FileTreeNode> - The root node of the file tree
- */
-export async function zipPathToFileTree(filePath) {
-    try {
-        // Normalize the path - remove /public prefix if present (Next.js serves public folder from root)
-        let normalizedPath = filePath;
-        if (normalizedPath.startsWith("/public/")) {
-            normalizedPath = normalizedPath.slice("/public".length);
-        }
-        // Ensure path starts with /
-        if (!normalizedPath.startsWith("/")) {
-            normalizedPath = "/" + normalizedPath;
-        }
-        // Build the URL - handle both client-side (relative) and server-side (absolute) cases
-        let url;
-        if (typeof window !== "undefined") {
-            // Client-side: use relative URL
-            url = normalizedPath;
-        }
-        else {
-            // Server-side: need absolute URL
-            // Try to get base URL from environment or use a default
-            const baseUrl = process.env.NEXT_PUBLIC_BASE_URL ||
-                process.env.VERCEL_URL ||
-                "http://localhost:3000";
-            url = `${baseUrl}${normalizedPath}`;
-        }
-        // Fetch the file from the public folder
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch zip file from ${url}: ${response.status} ${response.statusText}`);
-        }
-        // Get the file as a blob
-        const blob = await response.blob();
-        // Convert to FileTreeNode using zipToFileTree
-        return await zipToFileTree(blob);
-    }
-    catch (error) {
-        console.error(`Error reading zip file from path ${filePath}:`, error);
-        throw new Error(`Failed to read zip file from path: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Reads a zip file from a path and converts it to a FileTreeNode structure with binary file support
- * Binary files will have their content as base64 encoded strings
- * @param filePath - The path to the zip file (e.g., "/public/code/guardian/launchdarkly-guardian/code-1.zip" or "/code/guardian/launchdarkly-guardian/code-1.zip")
- * @returns Promise<FileTreeNode> - The root node of the file tree
- */
-export async function zipPathToFileTreeWithBinary(filePath) {
-    try {
-        // Normalize the path - remove /public prefix if present (Next.js serves public folder from root)
-        let normalizedPath = filePath;
-        if (normalizedPath.startsWith("/public/")) {
-            normalizedPath = normalizedPath.slice("/public".length);
-        }
-        // Ensure path starts with /
-        if (!normalizedPath.startsWith("/")) {
-            normalizedPath = "/" + normalizedPath;
-        }
-        // Build the URL - handle both client-side (relative) and server-side (absolute) cases
-        let url;
-        if (typeof window !== "undefined") {
-            // Client-side: use relative URL
-            url = normalizedPath;
-        }
-        else {
-            // Server-side: need absolute URL
-            // Try to get base URL from environment or use a default
-            const baseUrl = process.env.NEXT_PUBLIC_BASE_URL ||
-                process.env.VERCEL_URL ||
-                "http://localhost:3000";
-            url = `${baseUrl}${normalizedPath}`;
-        }
-        // Fetch the file from the public folder
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch zip file from ${url}: ${response.status} ${response.statusText}`);
-        }
-        // Get the file as a blob
-        const blob = await response.blob();
-        // Convert to FileTreeNode using zipToFileTreeWithBinary
-        return await zipToFileTreeWithBinary(blob);
-    }
-    catch (error) {
-        console.error(`Error reading zip file from path ${filePath}:`, error);
-        throw new Error(`Failed to read zip file from path: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}
-/**
- * Converts a zip file to a FileTreeNode structure with binary file support
- * Binary files will have their content as base64 encoded strings
- * @param zipData - The zip file as Blob, File, ArrayBuffer, or Uint8Array
- * @returns Promise<FileTreeNode> - The root node of the file tree
- */
-export async function zipToFileTreeWithBinary(zipData) {
-    try {
-        const zip = await JSZip.loadAsync(zipData);
-        // Create root node
-        const root = {
-            name: "root",
-            children: {},
-            type: "folder",
-            metadata: {
-                response_type: "CodeOutput",
-                file_path: "",
-                code_file_name: "",
-                code_language: CodeLanguage.TEXT,
-                dependencies_to_install: [],
-                framework: null,
-                full_code: "",
-            },
-        };
-        // Process all files in the zip
-        const filePromises = [];
-        for (const relativePath in zip.files) {
-            const file = zip.files[relativePath];
-            // Skip directories (they're handled by the path structure)
-            if (file.dir) {
-                continue;
-            }
-            // Try to read as text first, fallback to base64 for binary files
-            const contentPromise = (async () => {
-                let content;
-                try {
-                    // Try reading as text
-                    content = await file.async("string");
-                }
-                catch (_a) {
-                    // If that fails, read as base64
-                    const binary = await file.async("base64");
-                    content = binary;
-                }
-                // Build the tree structure from the path
-                const pathParts = relativePath.split("/").filter(Boolean);
-                let currentNode = root;
-                // Navigate/create folder structure
-                for (let i = 0; i < pathParts.length - 1; i++) {
-                    const part = pathParts[i];
-                    if (!currentNode.children[part]) {
-                        currentNode.children[part] = {
-                            name: part,
-                            children: {},
-                            type: "folder",
-                            metadata: {
-                                response_type: "CodeOutput",
-                                file_path: pathParts.slice(0, i + 1).join("/"),
-                                code_file_name: part,
-                                code_language: CodeLanguage.TEXT,
-                                dependencies_to_install: [],
-                                framework: null,
-                                full_code: "",
-                            },
-                        };
-                    }
-                    currentNode = currentNode.children[part];
-                }
-                // Add the file
-                const fileName = pathParts[pathParts.length - 1];
-                const filePath = relativePath;
-                const codeLanguage = filePathToCodeLanguage(filePath);
-                currentNode.children[fileName] = {
-                    name: fileName,
-                    children: {},
-                    type: "file",
-                    metadata: {
-                        response_type: "CodeOutput",
-                        file_path: filePath,
-                        code_file_name: fileName,
-                        code_language: codeLanguage,
-                        dependencies_to_install: [],
-                        framework: null,
-                        full_code: content,
-                    },
-                };
-            })();
-            filePromises.push(contentPromise);
-        }
-        // Wait for all files to be processed
-        await Promise.all(filePromises);
-        return root;
-    }
-    catch (error) {
-        console.error("Error parsing zip file:", error);
-        throw new Error(`Failed to parse zip file: ${error instanceof Error ? error.message : String(error)}`);
-    }
-}