@tanstack/cta-ui-base 0.15.4

package/dist/hooks/use-streaming-status.js

@@ -0,0 +1,55 @@
+import { useCallback, useState } from 'react';
+import { InfoIcon, MessageCircleCodeIcon, PackageIcon, SquarePenIcon, TerminalIcon, } from 'lucide-react';
+const iconMap = {
+    file: SquarePenIcon,
+    command: TerminalIcon,
+    'package-manager': PackageIcon,
+    info: InfoIcon,
+    other: MessageCircleCodeIcon,
+};
+export default function useStreamingStatus() {
+    const [streamItems, setStreamItems] = useState([]);
+    const [finished, setFinished] = useState(false);
+    const monitorStream = useCallback(async (res) => {
+        setFinished(false);
+        const reader = res.body?.getReader();
+        const decoder = new TextDecoder();
+        let rawStream = '';
+        while (true) {
+            const result = await reader?.read();
+            if (result?.done)
+                break;
+            rawStream += decoder.decode(result?.value);
+            let currentId;
+            const newStreamItems = [];
+            for (const line of rawStream.split('\n')) {
+                if (line.startsWith('{') && line.endsWith('}')) {
+                    const item = JSON.parse(line);
+                    if (item.msgType === 'start') {
+                        if (currentId === item.id) {
+                            newStreamItems[newStreamItems.length - 1].message = item.message;
+                        }
+                        else {
+                            currentId = item.id;
+                            newStreamItems.push({
+                                id: currentId,
+                                icon: iconMap[item.type],
+                                message: item.message,
+                            });
+                        }
+                    }
+                    else {
+                        if (newStreamItems.length > 0) {
+                            newStreamItems[newStreamItems.length - 1].message = item.message;
+                        }
+                        currentId = undefined;
+                    }
+                }
+            }
+            setStreamItems(newStreamItems);
+        }
+        setFinished(true);
+        return rawStream;
+    }, []);
+    return { finished, streamItems, monitorStream };
+}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import RootComponent from './app';
+import { AppSidebar } from './components/cta-sidebar';
+import { AppHeader } from './components/header';
+import { BackgroundAnimation } from './components/background-animation';
+import { Toaster } from './components/toaster';
+import FileNavigator from './components/file-navigator';
+import StartupDialog from './components/startup-dialog';
+import { QueryProvider } from './components/query-provider';
+import { CTAProvider } from './components/cta-provider';
+import SelectedAddOns from './components/sidebar-items/add-ons';
+import RunAddOns from './components/sidebar-items/run-add-ons';
+import RunCreateApp from './components/sidebar-items/run-create-app';
+import ProjectName from './components/sidebar-items/project-name';
+import ModeSelector from './components/sidebar-items/mode-selector';
+import TypescriptSwitch from './components/sidebar-items/typescript-switch';
+import StarterDialog from './components/sidebar-items/starter';
+import SidebarGroup from './components/sidebar-items/sidebar-group';
+import { useApplicationMode, useManager, useReady } from './store/project';
+export { FileNavigator, AppSidebar, AppHeader, BackgroundAnimation, Toaster, StartupDialog, QueryProvider, CTAProvider, SelectedAddOns, RunAddOns, RunCreateApp, ProjectName, ModeSelector, TypescriptSwitch, StarterDialog, SidebarGroup, useApplicationMode, useManager, useReady, };
+export default RootComponent;

package/dist/index.js

@@ -0,0 +1,20 @@
+import RootComponent from './app';
+import { AppSidebar } from './components/cta-sidebar';
+import { AppHeader } from './components/header';
+import { BackgroundAnimation } from './components/background-animation';
+import { Toaster } from './components/toaster';
+import FileNavigator from './components/file-navigator';
+import StartupDialog from './components/startup-dialog';
+import { QueryProvider } from './components/query-provider';
+import { CTAProvider } from './components/cta-provider';
+import SelectedAddOns from './components/sidebar-items/add-ons';
+import RunAddOns from './components/sidebar-items/run-add-ons';
+import RunCreateApp from './components/sidebar-items/run-create-app';
+import ProjectName from './components/sidebar-items/project-name';
+import ModeSelector from './components/sidebar-items/mode-selector';
+import TypescriptSwitch from './components/sidebar-items/typescript-switch';
+import StarterDialog from './components/sidebar-items/starter';
+import SidebarGroup from './components/sidebar-items/sidebar-group';
+import { useApplicationMode, useManager, useReady } from './store/project';
+export { FileNavigator, AppSidebar, AppHeader, BackgroundAnimation, Toaster, StartupDialog, QueryProvider, CTAProvider, SelectedAddOns, RunAddOns, RunCreateApp, ProjectName, ModeSelector, TypescriptSwitch, StarterDialog, SidebarGroup, useApplicationMode, useManager, useReady, };
+export default RootComponent;

package/dist/lib/api.d.ts

@@ -0,0 +1,14 @@
+import type { SerializedOptions } from '@tanstack/cta-engine';
+import type { AddOnInfo, DryRunOutput, InitialData, StarterInfo } from '../types';
+export declare function createAppStreaming(options: SerializedOptions, chosenAddOns: Array<string>, projectStarter?: StarterInfo): Promise<Response>;
+export declare function addToAppStreaming(chosenAddOns: Array<string>): Promise<Response>;
+export declare function shutdown(): Promise<Response>;
+export declare function loadRemoteAddOn(url: string): Promise<AddOnInfo | {
+    error: string;
+}>;
+export declare function loadRemoteStarter(url: string): Promise<StarterInfo | {
+    error: string;
+}>;
+export declare function loadInitialData(): Promise<InitialData>;
+export declare function dryRunCreateApp(options: SerializedOptions, chosenAddOns: Array<string>, projectStarter?: StarterInfo): Promise<DryRunOutput>;
+export declare function dryRunAddToApp(addOns: Array<string>): Promise<DryRunOutput>;

package/dist/lib/api.js

@@ -0,0 +1,74 @@
+// @ts-ignore - import.meta.env is not available in the browser
+const baseUrl = import.meta.env.VITE_API_BASE_URL || '';
+export async function createAppStreaming(options, chosenAddOns, projectStarter) {
+    return await fetch(`${baseUrl}/api/create-app`, {
+        method: 'POST',
+        body: JSON.stringify({
+            options: {
+                ...options,
+                chosenAddOns,
+                starter: projectStarter?.url || undefined,
+            },
+        }),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+}
+export async function addToAppStreaming(chosenAddOns) {
+    return await fetch(`${baseUrl}/api/add-to-app`, {
+        method: 'POST',
+        body: JSON.stringify({
+            addOns: chosenAddOns,
+        }),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    });
+}
+export function shutdown() {
+    return fetch(`${baseUrl}/api/shutdown`, {
+        method: 'POST',
+    });
+}
+export async function loadRemoteAddOn(url) {
+    const response = await fetch(`${baseUrl}/api/load-remote-add-on?url=${url}`);
+    return (await response.json());
+}
+export async function loadRemoteStarter(url) {
+    const response = await fetch(`${baseUrl}/api/load-starter?url=${url}`);
+    return (await response.json());
+}
+const initialDataRequest = fetch(`${baseUrl}/api/initial-payload`);
+export async function loadInitialData() {
+    const payloadReq = await initialDataRequest;
+    return (await payloadReq.json());
+}
+export async function dryRunCreateApp(options, chosenAddOns, projectStarter) {
+    const outputReq = await fetch(`${baseUrl}/api/dry-run-create-app`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            options: {
+                ...options,
+                chosenAddOns: chosenAddOns,
+                starter: projectStarter?.url,
+            },
+        }),
+    });
+    return outputReq.json();
+}
+export async function dryRunAddToApp(addOns) {
+    const outputReq = await fetch(`${baseUrl}/api/dry-run-add-to-app`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            addOns,
+        }),
+    });
+    return outputReq.json();
+}

package/dist/lib/utils.d.ts

@@ -0,0 +1,2 @@
+import type { ClassValue } from 'clsx';
+export declare function cn(...inputs: Array<ClassValue>): string;

package/dist/lib/utils.js

@@ -0,0 +1,5 @@
+import { clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+export function cn(...inputs) {
+    return twMerge(clsx(inputs));
+}

package/dist/store/add-ons.d.ts

@@ -0,0 +1,7 @@
+import type { AddOnInfo } from '../types';
+export declare function getAddOnStatus(availableAddOns: Array<AddOnInfo>, chosenAddOns: Array<string>, originalAddOns: Array<string>): {
+    [k: string]: {
+        enabled: boolean;
+        selected: boolean;
+    };
+};

package/dist/store/add-ons.js

@@ -0,0 +1,59 @@
+export function getAddOnStatus(availableAddOns, chosenAddOns, originalAddOns) {
+    const addOnMap = new Map();
+    for (const addOn of availableAddOns) {
+        addOnMap.set(addOn.id, {
+            selected: false,
+            enabled: true,
+            dependedUpon: false,
+        });
+    }
+    // Guard against cycles in the dependency graph. The results won't be great. But it won't crash.
+    function cycleGuardedSelectAndDisableDependsOn(startingAddOnId) {
+        const visited = new Set();
+        function selectAndDisableDependsOn(addOnId) {
+            if (visited.has(addOnId)) {
+                return;
+            }
+            visited.add(addOnId);
+            const selectedAddOn = availableAddOns.find((addOn) => addOn.id === addOnId);
+            if (selectedAddOn) {
+                for (const dependsOnId of selectedAddOn.dependsOn || []) {
+                    const dependsOnAddOn = addOnMap.get(dependsOnId);
+                    if (dependsOnAddOn) {
+                        dependsOnAddOn.selected = true;
+                        dependsOnAddOn.enabled = false;
+                        dependsOnAddOn.dependedUpon = true;
+                        selectAndDisableDependsOn(dependsOnId);
+                    }
+                }
+                const addOn = addOnMap.get(addOnId);
+                if (addOn) {
+                    addOn.selected = true;
+                    if (!addOn.dependedUpon) {
+                        addOn.enabled = true;
+                    }
+                }
+            }
+        }
+        selectAndDisableDependsOn(startingAddOnId);
+    }
+    for (const addOn of originalAddOns) {
+        const addOnInfo = addOnMap.get(addOn);
+        if (addOnInfo) {
+            addOnInfo.selected = true;
+            addOnInfo.enabled = false;
+            addOnInfo.dependedUpon = true;
+        }
+        cycleGuardedSelectAndDisableDependsOn(addOn);
+    }
+    for (const addOnId of chosenAddOns) {
+        cycleGuardedSelectAndDisableDependsOn(addOnId);
+    }
+    return Object.fromEntries(Array.from(addOnMap.entries()).map(([v, addOn]) => [
+        v,
+        {
+            enabled: addOn.enabled,
+            selected: addOn.selected,
+        },
+    ]));
+}

package/dist/store/project.d.ts

@@ -0,0 +1,76 @@
+import type { AddOnInfo, DryRunOutput, StarterInfo } from '../types';
+export declare const useProjectOptions: import("zustand").UseBoundStore<import("zustand").StoreApi<Omit<import("@tanstack/cta-engine").Options, "chosenAddOns" | "starter" | "framework"> & {
+    chosenAddOns: Array<string>;
+    starter?: string | undefined;
+    framework: string;
+} & {
+    initialized: boolean;
+}>>;
+export declare const useReady: () => boolean;
+export declare const useRegistry: () => import("../types").Registry | undefined;
+export declare const useProjectLocalFiles: () => Record<string, string> | undefined;
+export declare const useOriginalOutput: () => any;
+export declare const useOriginalOptions: () => any;
+export declare const useOriginalSelectedAddOns: () => any;
+export declare const useApplicationMode: () => import("../types").ApplicationMode | undefined;
+export declare const useAddOnsByMode: () => Record<string, AddOnInfo[]> | undefined;
+export declare const useSupportedModes: () => Record<string, {
+    displayName: string;
+    description: string;
+    forceTypescript: boolean;
+}> | undefined;
+export declare const useProjectStarter: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    projectStarter: StarterInfo | undefined;
+}>>;
+export declare function addCustomAddOn(addOn: AddOnInfo): void;
+export declare function useAddOns(): {
+    toggleAddOn: (addOnId: string) => void;
+    chosenAddOns: string[];
+    availableAddOns: AddOnInfo[];
+    userSelectedAddOns: string[];
+    originalSelectedAddOns: any;
+    addOnState: {
+        [k: string]: {
+            enabled: boolean;
+            selected: boolean;
+        };
+    };
+};
+export declare const useModeEditable: () => boolean;
+export declare const useTypeScriptEditable: () => boolean;
+export declare const useTailwindEditable: () => boolean;
+export declare const useProjectName: () => string;
+export declare const useRouterMode: () => string;
+export declare function useFilters(): {
+    includedFiles: string[];
+    toggleFilter: (filter: string) => void;
+};
+export declare function useDryRun(): DryRunOutput;
+type StartupDialogState = {
+    open: boolean;
+    dontShowAgain: boolean;
+    setOpen: (open: boolean) => void;
+    setDontShowAgain: (dontShowAgain: boolean) => void;
+};
+export declare const useStartupDialog: import("zustand").UseBoundStore<Omit<import("zustand").StoreApi<StartupDialogState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import("zustand/middleware").PersistOptions<StartupDialogState, {
+            dontShowAgain: boolean;
+        }>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: StartupDialogState) => void) => () => void;
+        onFinishHydration: (fn: (state: StartupDialogState) => void) => () => void;
+        getOptions: () => Partial<import("zustand/middleware").PersistOptions<StartupDialogState, {
+            dontShowAgain: boolean;
+        }>>;
+    };
+}>;
+export declare const setProjectName: (projectName: string) => void;
+export declare const setRouterMode: (mode: string) => void;
+export declare function setTypeScript(typescript: boolean): void;
+export declare function setTailwind(tailwind: boolean): void;
+export declare function setProjectStarter(starter: StarterInfo | undefined): void;
+export declare function useManager(): void;
+export {};

package/dist/store/project.js

@@ -0,0 +1,269 @@
+import { useCallback, useEffect, useMemo } from 'react';
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import { useQuery } from '@tanstack/react-query';
+import { dryRunAddToApp, dryRunCreateApp, loadInitialData } from '../lib/api';
+import { getAddOnStatus } from './add-ons';
+export const useProjectOptions = create(() => ({
+    initialized: false,
+    framework: '',
+    mode: '',
+    projectName: '',
+    targetDir: '',
+    typescript: true,
+    tailwind: true,
+    git: true,
+    chosenAddOns: [],
+    packageManager: 'pnpm',
+}));
+const useInitialData = () => useQuery({
+    queryKey: ['initial-data'],
+    queryFn: loadInitialData,
+});
+export const useReady = () => {
+    const { data } = useInitialData();
+    return data !== undefined;
+};
+const useForcedRouterMode = () => useInitialData().data?.forcedRouterMode;
+const useForcedAddOns = () => useInitialData().data?.forcedAddOns;
+export const useRegistry = () => useInitialData().data?.registry;
+export const useProjectLocalFiles = () => useInitialData().data?.localFiles;
+export const useOriginalOutput = () => useInitialData().data?.output;
+export const useOriginalOptions = () => useInitialData().data?.options;
+export const useOriginalSelectedAddOns = () => useOriginalOptions()?.chosenAddOns;
+export const useApplicationMode = () => useInitialData().data?.applicationMode;
+export const useAddOnsByMode = () => useInitialData().data?.addOns;
+export const useSupportedModes = () => useInitialData().data?.supportedModes;
+const useApplicationSettings = create(() => ({
+    includeFiles: ['unchanged', 'added', 'modified', 'deleted', 'overwritten'],
+}));
+const useMutableAddOns = create(() => ({
+    userSelectedAddOns: [],
+    customAddOns: [],
+}));
+export const useProjectStarter = create(() => ({
+    projectStarter: undefined,
+}));
+export function addCustomAddOn(addOn) {
+    useMutableAddOns.setState((state) => ({
+        customAddOns: [...state.customAddOns, addOn],
+    }));
+    if (addOn.modes.includes(useProjectOptions.getState().mode)) {
+        useMutableAddOns.setState((state) => ({
+            userSelectedAddOns: [...state.userSelectedAddOns, addOn.id],
+        }));
+    }
+}
+export function useAddOns() {
+    const ready = useReady();
+    const routerMode = useRouterMode();
+    const originalSelectedAddOns = useOriginalSelectedAddOns();
+    const addOnsByMode = useAddOnsByMode();
+    const forcedAddOns = useForcedAddOns();
+    const { userSelectedAddOns, customAddOns } = useMutableAddOns();
+    const projectStarter = useProjectStarter().projectStarter;
+    const availableAddOns = useMemo(() => {
+        if (!ready)
+            return [];
+        const baseAddOns = addOnsByMode?.[routerMode] || [];
+        return [
+            ...baseAddOns,
+            ...customAddOns.filter((addOn) => addOn.modes.includes(routerMode)),
+        ];
+    }, [ready, routerMode, addOnsByMode, customAddOns]);
+    const addOnState = useMemo(() => {
+        if (!ready)
+            return {};
+        const originalAddOns = new Set();
+        for (const addOn of projectStarter?.dependsOn || []) {
+            originalAddOns.add(addOn);
+        }
+        for (const addOn of originalSelectedAddOns) {
+            originalAddOns.add(addOn);
+        }
+        for (const addOn of forcedAddOns || []) {
+            originalAddOns.add(addOn);
+        }
+        return getAddOnStatus(availableAddOns, userSelectedAddOns, Array.from(originalAddOns));
+    }, [
+        ready,
+        availableAddOns,
+        userSelectedAddOns,
+        originalSelectedAddOns,
+        projectStarter?.dependsOn,
+        forcedAddOns,
+    ]);
+    const chosenAddOns = useMemo(() => {
+        if (!ready)
+            return [];
+        const addOns = new Set(Object.keys(addOnState).filter((addOn) => addOnState[addOn].selected));
+        for (const addOn of forcedAddOns || []) {
+            addOns.add(addOn);
+        }
+        return Array.from(addOns);
+    }, [ready, addOnState, forcedAddOns]);
+    const toggleAddOn = useCallback((addOnId) => {
+        if (!ready)
+            return;
+        if (addOnState[addOnId].enabled) {
+            if (addOnState[addOnId].selected) {
+                useMutableAddOns.setState((state) => ({
+                    userSelectedAddOns: state.userSelectedAddOns.filter((addOn) => addOn !== addOnId),
+                }));
+            }
+            else {
+                useMutableAddOns.setState((state) => ({
+                    userSelectedAddOns: [...state.userSelectedAddOns, addOnId],
+                }));
+            }
+        }
+    }, [ready, addOnState]);
+    return {
+        toggleAddOn,
+        chosenAddOns,
+        availableAddOns,
+        userSelectedAddOns,
+        originalSelectedAddOns,
+        addOnState,
+    };
+}
+const useHasProjectStarter = () => useProjectStarter((state) => state.projectStarter === undefined);
+export const useModeEditable = () => {
+    const ready = useReady();
+    const forcedRouterMode = useForcedRouterMode();
+    const hasProjectStarter = useHasProjectStarter();
+    return ready ? !forcedRouterMode && hasProjectStarter : false;
+};
+export const useTypeScriptEditable = () => {
+    const ready = useReady();
+    const hasProjectStarter = useHasProjectStarter();
+    const routerMode = useRouterMode();
+    return ready ? hasProjectStarter && routerMode === 'code-router' : false;
+};
+export const useTailwindEditable = () => {
+    const ready = useReady();
+    const hasProjectStarter = useHasProjectStarter();
+    const routerMode = useRouterMode();
+    return ready ? hasProjectStarter && routerMode === 'code-router' : false;
+};
+export const useProjectName = () => useProjectOptions((state) => state.projectName);
+export const useRouterMode = () => {
+    const ready = useReady();
+    const forcedRouterMode = useForcedRouterMode();
+    const userMode = useProjectOptions((state) => state.mode);
+    return ready ? forcedRouterMode || userMode : 'file-router';
+};
+export function useFilters() {
+    const ready = useReady();
+    const includedFiles = useApplicationSettings((state) => state.includeFiles);
+    const toggleFilter = useCallback((filter) => {
+        if (!ready)
+            return;
+        useApplicationSettings.setState((state) => ({
+            includeFiles: state.includeFiles.includes(filter)
+                ? state.includeFiles.filter((f) => f !== filter)
+                : [...state.includeFiles, filter],
+        }));
+    }, [ready]);
+    return {
+        includedFiles,
+        toggleFilter,
+    };
+}
+export function useDryRun() {
+    const ready = useReady();
+    const applicationMode = useApplicationMode();
+    const { initialized, ...projectOptions } = useProjectOptions();
+    const { userSelectedAddOns, chosenAddOns } = useAddOns();
+    const projectStarter = useProjectStarter().projectStarter;
+    const { data: dryRunOutput } = useQuery({
+        queryKey: [
+            'dry-run',
+            applicationMode,
+            JSON.stringify(projectOptions),
+            JSON.stringify(userSelectedAddOns),
+            projectStarter?.url,
+        ],
+        queryFn: async () => {
+            if (applicationMode === 'none' || !ready || !initialized) {
+                return {
+                    files: {},
+                    commands: [],
+                    deletedFiles: [],
+                };
+            }
+            else if (applicationMode === 'setup') {
+                return dryRunCreateApp(projectOptions, chosenAddOns, projectStarter);
+            }
+            else {
+                return dryRunAddToApp(userSelectedAddOns);
+            }
+        },
+        enabled: ready,
+        initialData: {
+            files: {},
+            commands: [],
+            deletedFiles: [],
+        },
+    });
+    return dryRunOutput;
+}
+export const useStartupDialog = create()(persist((set) => ({
+    open: false,
+    dontShowAgain: false,
+    setOpen: (open) => set({ open }),
+    setDontShowAgain: (dontShowAgain) => set({ dontShowAgain }),
+}), {
+    name: 'startup-dialog',
+    partialize: (state) => ({
+        dontShowAgain: state.dontShowAgain,
+    }),
+    merge: (persistedState, currentState) => {
+        if (persistedState &&
+            persistedState.dontShowAgain) {
+            currentState.open = false;
+        }
+        else {
+            currentState.open = true;
+        }
+        return currentState;
+    },
+}));
+export const setProjectName = (projectName) => useProjectOptions.setState({
+    projectName,
+});
+export const setRouterMode = (mode) => useProjectOptions.setState({
+    mode,
+});
+export function setTypeScript(typescript) {
+    useProjectOptions.setState({
+        typescript,
+    });
+}
+export function setTailwind(tailwind) {
+    useProjectOptions.setState({
+        tailwind,
+    });
+}
+export function setProjectStarter(starter) {
+    useProjectStarter.setState(() => ({
+        projectStarter: starter,
+    }));
+    if (starter) {
+        useProjectOptions.setState({
+            mode: starter.mode,
+        });
+    }
+}
+export function useManager() {
+    const ready = useReady();
+    const originalOptions = useOriginalOptions();
+    useEffect(() => {
+        if (ready) {
+            useProjectOptions.setState({
+                ...originalOptions,
+                initialized: true,
+            });
+        }
+    }, [ready]);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@tanstack/cta-ui-base",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@codemirror/lang-css": "^6.3.1",
+    "@codemirror/lang-html": "^6.4.9",
+    "@codemirror/lang-javascript": "^6.2.3",
+    "@codemirror/lang-json": "^6.0.1",
+    "@radix-ui/react-accordion": "^1.2.3",
+    "@radix-ui/react-checkbox": "^1.1.4",
+    "@radix-ui/react-dialog": "^1.1.10",
+    "@radix-ui/react-dropdown-menu": "^2.1.11",
+    "@radix-ui/react-label": "^2.1.4",
+    "@radix-ui/react-popover": "^1.1.10",
+    "@radix-ui/react-separator": "^1.1.4",
+    "@radix-ui/react-slot": "^1.2.0",
+    "@radix-ui/react-switch": "^1.2.2",
+    "@radix-ui/react-tabs": "^1.1.3",
+    "@radix-ui/react-toggle": "^1.1.2",
+    "@radix-ui/react-toggle-group": "^1.1.2",
+    "@radix-ui/react-tooltip": "^1.2.3",
+    "@tanstack/react-query": "^5.66.5",
+    "@uiw/codemirror-theme-github": "^4.23.10",
+    "@uiw/react-codemirror": "^4.23.10",
+    "chalk": "^5.4.1",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "embla-carousel-react": "^8.6.0",
+    "lucide-react": "^0.476.0",
+    "next-themes": "^0.4.6",
+    "react": "^19.0.0",
+    "react-codemirror-merge": "^4.23.10",
+    "react-dom": "^19.0.0",
+    "sonner": "^2.0.3",
+    "tailwind-merge": "^3.0.2",
+    "zustand": "^5.0.3",
+    "@tanstack/cta-engine": "0.15.4"
+  },
+  "devDependencies": {
+    "@types/react": "^19.0.8",
+    "@types/react-dom": "^19.0.3",
+    "typescript": "^5.7.2",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.1.4"
+  },
+  "version": "0.15.4",
+  "scripts": {}
+}