@juggernautlabs/views 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Juggernaut Labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli.js

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+
+// bin/cli.js
+import { cac } from "cac";
+
+// src/bundler.js
+import { build } from "vite";
+import react from "@vitejs/plugin-react";
+import { viteSingleFile } from "vite-plugin-singlefile";
+import path3 from "path";
+
+// src/uploader.js
+import fs2 from "fs";
+import path2 from "path";
+import JSON52 from "json5";
+
+// src/api.js
+import fs from "fs";
+import path from "path";
+import JSON5 from "json5";
+import dotenv from "dotenv";
+var BASE_ROUTE = "https://core.juggernautlabs.ai";
+var buildRoute = (route) => {
+  return `${BASE_ROUTE}${route}`;
+};
+var isEnvLoaded = false;
+var loadEnvVariable = (key, defaultValue = "") => {
+  if (!isEnvLoaded) {
+    const envPath = path.resolve(process.cwd(), ".env");
+    if (fs.existsSync(envPath)) {
+      dotenv.config({ path: envPath });
+    }
+    isEnvLoaded = true;
+  }
+  const value = import.meta.env?.[key] || process.env?.[key];
+  return value || defaultValue;
+};
+var executeRequest = async (route, method = "POST", body = null, headers = {}) => {
+  const url = buildRoute(route);
+  const options = {
+    method,
+    headers: {
+      ...headers,
+      authorization: `Bearer ${await loadEnvVariable("JUGGERNAUT_API_KEY")}`,
+      "client-key": `${await loadEnvVariable("JUGGERNAUT_CLIENT_ID")}`
+    }
+  };
+  if (body) {
+    if (body instanceof FormData) {
+      options.body = body;
+    } else {
+      options.headers["Content-Type"] = "application/json";
+      options.body = JSON.stringify(body);
+    }
+  }
+  const response = await fetch(url, options);
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Request failed with status ${response.status}: ${errorText}`);
+  }
+  return response.json();
+};
+
+// src/uploader.js
+import { promises } from "fs";
+var ROUTES = {
+  ingest: "/api/resource/ui/template/ingest",
+  uploadSolution: "/api/resource/ui/template/upload/solution",
+  create: "/api/resource/ui/template"
+};
+
+class TemplateUploader {
+  static async parseMetadataFile(filePath) {
+    if (!fs2.existsSync(filePath)) {
+      throw new Error(`Metadata file not found at path: ${filePath}`);
+    }
+    try {
+      const fileContent = await fs2.readFileSync(filePath, "utf-8");
+      const metadata = JSON52.parse(fileContent) || {};
+      return {
+        name: metadata.name || "Untitled Template",
+        description: metadata.description || "",
+        tags: metadata.tags || [],
+        target: {
+          role: metadata.target?.role,
+          resource: metadata.target?.resource,
+          resourceType: metadata.target?.resourceType
+        }
+      };
+    } catch (e) {
+      throw new Error("Invalid JSON in metadata file");
+    }
+  }
+  static async findConfigFile() {
+    const currentDir = process.cwd();
+    const configFilePath = path2.join(currentDir, ".juggernauttemplate");
+    if (fs2.existsSync(configFilePath)) {
+      return this.parseMetadataFile(configFilePath);
+    } else {
+      return null;
+    }
+  }
+  static async upload(file, metadataPath = null) {
+    let templateDetails = {};
+    if (metadataPath) {
+      templateDetails = await this.parseMetadataFile(metadataPath);
+    }
+    return this.uploadTemplate(templateDetails, file);
+  }
+  static async getUploadURL() {
+    const { data } = await executeRequest(ROUTES.uploadSolution, "GET");
+    return data;
+  }
+  static createTemplate(templateDetails) {
+    return executeRequest(ROUTES.ingest, "POST", templateDetails);
+  }
+  static async uploadTemplate(viewTemplateDetails, templatePath) {
+    const { name, url } = await this.getUploadURL();
+    const fileContent = await promises.readFile(templatePath);
+    const uploadSolutionResponse = await fetch(url, {
+      method: "PUT",
+      headers: {
+        "Content-Type": "application/html",
+        "x-ms-blob-type": "BlockBlob"
+      },
+      body: fileContent
+    });
+    if (uploadSolutionResponse.ok) {
+      console.log("Upload successful!");
+    } else {
+      const errorText = await uploadSolutionResponse.text();
+      throw new Error(`Failed to upload: ${uploadSolutionResponse.status} - ${errorText}`);
+    }
+    return this.createTemplate({
+      ...viewTemplateDetails,
+      solution: name
+    });
+  }
+}
+
+// src/bundler.js
+import fs3 from "fs";
+async function bundle({ entry, outDir, root, template = {} }) {
+  const isScript = /\.(js|ts|jsx|tsx)$/.test(entry);
+  let viteConfig = {
+    root,
+    configFile: false,
+    plugins: [
+      react(),
+      viteSingleFile({
+        useRecommendedBuildConfig: true,
+        removeViteModuleLoader: true
+      }),
+      isScript && virtualHtmlPlugin(entry)
+    ],
+    build: {
+      outDir,
+      emptyOutDir: true,
+      minify: true
+    }
+  };
+  await build(viteConfig);
+  const bundlePath = path3.join(outDir, "index.html");
+  return TemplateUploader.uploadTemplate(template, bundlePath);
+}
+function virtualHtmlPlugin(entryScriptPath) {
+  const virtualHtmlId = "index.html";
+  const resolvedHtmlId = "/index.html";
+  const virtualEntryId = "virtual-auto-mount.tsx";
+  const resolvedEntryId = "\x00virtual-auto-mount.tsx";
+  return {
+    name: "auto-html-entry",
+    resolveId(id) {
+      if (id === virtualHtmlId)
+        return resolvedHtmlId;
+      if (id === virtualEntryId)
+        return resolvedEntryId;
+    },
+    load(id) {
+      if (id === resolvedHtmlId) {
+        const code = fs3.readFileSync(entryScriptPath, "utf-8");
+        const hasRender = code.includes("ReactDOM") || code.includes("createRoot");
+        const entrySrc = hasRender ? `/${path3.relative(process.cwd(), entryScriptPath)}` : virtualEntryId;
+        return `
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <meta charset="utf-8">
+              <title>React App</title>
+              <style>html,body,#root{height:100%;margin:0;}</style>
+            </head>
+            <body>
+              <div id="root"></div>
+              <script type="module" src="${entrySrc}"></script>
+            </body>
+          </html>
+        `;
+      }
+      if (id === resolvedEntryId) {
+        const importPath = entryScriptPath.split(path3.sep).join("/");
+        return `
+          import React from 'react';
+          import ReactDOM from 'react-dom/client';
+          import UserApp from '${importPath}';
+          
+          const root = ReactDOM.createRoot(document.getElementById('root'));
+          root.render(
+            React.createElement(React.StrictMode, null, 
+              React.createElement(UserApp)
+            )
+          );
+        `;
+      }
+    },
+    configureServer(server) {
+      server.middlewares.use((req, res, next) => {
+        if (req.url === "/")
+          req.url = "/index.html";
+        next();
+      });
+    },
+    config() {
+      return {
+        build: {
+          rollupOptions: { input: resolvedHtmlId }
+        }
+      };
+    }
+  };
+}
+function getViteConfig({ entry, root, outDir, isDev = false }) {
+  const isScript = /\.(js|ts|jsx|tsx)$/.test(entry);
+  const plugins = [
+    react(),
+    !isDev && viteSingleFile({
+      useRecommendedBuildConfig: true,
+      removeViteModuleLoader: true
+    }),
+    isScript && virtualHtmlPlugin(entry)
+  ].filter(Boolean);
+  return {
+    root,
+    configFile: false,
+    plugins,
+    server: {
+      fs: {
+        allow: [root, process.cwd()]
+      }
+    },
+    build: {
+      outDir,
+      emptyOutDir: true,
+      minify: !isDev,
+      assetsInlineLimit: 1e8,
+      rollupOptions: {
+        output: {
+          inlineDynamicImports: !isDev
+        }
+      }
+    }
+  };
+}
+
+// bin/cli.js
+import path4 from "path";
+import { createServer } from "vite";
+var cli = cac("templatebundler");
+cli.command("<entry>", "Bundle the React app into a single file").option("-o, --output <path>", "Output directory", { default: "dist" }).option("-c, --config <path>", "Input config file (.juggernauttemplate) or a .json file").action(async (entry, options) => {
+  try {
+    const rootDir = process.cwd();
+    const absoluteEntry = path4.resolve(rootDir, entry);
+    const absoluteOutput = path4.resolve(rootDir, options.output);
+    const configPath = options.config ? path4.resolve(rootDir, options.config) : null;
+    console.log(`\uD83D\uDCE6 Bundling ${entry}...`);
+    const template = configPath ? await TemplateUploader.parseMetadataFile(configPath) : await TemplateUploader.findConfigFile();
+    if (template)
+      console.log(`\uD83D\uDCDD Using template config: ${configPath || ".juggernauttemplate"}`);
+    else
+      throw new Error("No template configuration provided and no .juggernauttemplate file found.");
+    await bundle({
+      entry: absoluteEntry,
+      outDir: absoluteOutput,
+      root: rootDir,
+      template
+    });
+    console.log(`✅ Done! Output saved to ${options.output}`);
+  } catch (e) {
+    console.error("❌ Build failed:", e);
+    process.exit(1);
+  }
+});
+cli.command("dev <entry>", "Start a dev server with HMR").option("-p, --port <port>", "Port to listen on", { default: 5173 }).action(async (entry, options) => {
+  try {
+    const rootDir = process.cwd();
+    const absoluteEntry = path4.resolve(rootDir, entry);
+    console.log(`⚡ Starting Dev Server for ${entry}...`);
+    const viteConfig = getViteConfig({
+      entry: absoluteEntry,
+      root: rootDir,
+      outDir: "dist",
+      isDev: true
+    });
+    const server = await createServer({
+      ...viteConfig,
+      server: {
+        port: options.port,
+        host: true
+      }
+    });
+    await server.listen();
+    server.printUrls();
+    console.log(`
+\uD83E\uDDEA Demo Data: ensure you have a .demo.json in your root to mock server data.`);
+  } catch (e) {
+    console.error("❌ Dev server failed:", e);
+    process.exit(1);
+  }
+});
+cli.help();
+cli.parse();

package/dist/index.js

@@ -0,0 +1,308 @@
+// src/hooks.jsx
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/context.js
+var STORE_KEY = Symbol("ContextStore");
+
+class ContextManager {
+  static [STORE_KEY] = {
+    job: null,
+    record: null,
+    data: null,
+    plugin: null,
+    process: null,
+    actions: [],
+    system: null
+  };
+}
+
+// src/hooks.jsx
+var IS_DEV_MODE = import.meta.env ? import.meta.env.DEV : process?.env.NODE_ENV === "development";
+var DEMO_FILE_PATH = "/.demo.json";
+var subscribers = new Set;
+var isListening = false;
+var handleContextWindowEvents = (event) => {
+  const { type, payload } = event.data || {};
+  if (!type || !payload)
+    return;
+  const { resourceType, resource } = payload;
+  switch (type) {
+    case "juggernaut:context:request":
+      if (ContextManager[STORE_KEY] && ContextManager[STORE_KEY].hasOwnProperty(resourceType)) {
+        const currentResource = ContextManager[STORE_KEY][resourceType];
+        window.parent.postMessage({
+          type: "juggernaut:context:response",
+          payload: { resourceType, resource: currentResource }
+        }, "*");
+      }
+      break;
+    case "juggernaut:context:update":
+      if (ContextManager[STORE_KEY]) {
+        ContextManager[STORE_KEY][resourceType] = resource;
+        subscribers.forEach((callback) => callback(resourceType, resource));
+      }
+      break;
+    default:
+      break;
+  }
+};
+var listenForJuggernautPlatformEvents = () => {
+  if (typeof window === "undefined")
+    return;
+  if (!window.parent && !IS_DEV_MODE)
+    return;
+  if (!isListening) {
+    window.addEventListener("message", handleContextWindowEvents);
+    isListening = true;
+  }
+};
+var useJuggernautResource = (resourceType) => {
+  const [resource, setResource] = useState(() => {
+    if (ContextManager[STORE_KEY] && ContextManager[STORE_KEY][resourceType]) {
+      return ContextManager[STORE_KEY][resourceType];
+    }
+    return null;
+  });
+  useEffect(() => {
+    let isMounted = true;
+    const tryLoadDemoData = async () => {
+      try {
+        const response = await fetch(DEMO_FILE_PATH);
+        if (!response.ok)
+          throw new Error("No demo file");
+        const demoData = await response.json();
+        if (demoData && demoData[resourceType] && isMounted) {
+          console.log(`[Juggernaut SDK] Loaded DEMO data for: ${resourceType}`);
+          if (ContextManager[STORE_KEY]) {
+            ContextManager[STORE_KEY][resourceType] = demoData[resourceType];
+          }
+          setResource(demoData[resourceType]);
+          return true;
+        }
+      } catch (err) {
+        console.warn("[Juggernaut SDK] Dev mode active, but no valid .demo.json found.");
+      }
+      return false;
+    };
+    const initialize = async () => {
+      if (IS_DEV_MODE) {
+        const loadedFromDemo = await tryLoadDemoData();
+        if (loadedFromDemo)
+          return;
+      }
+      listenForJuggernautPlatformEvents();
+      const handleUpdate = (type, data) => {
+        if (isMounted && type === resourceType) {
+          setResource(data);
+        }
+      };
+      subscribers.add(handleUpdate);
+      if (!resource && window.parent) {
+        window.parent.postMessage({
+          type: "juggernaut:context:request",
+          payload: { resourceType }
+        }, "*");
+      }
+      return () => {
+        subscribers.delete(handleUpdate);
+      };
+    };
+    const cleanupFnPromise = initialize();
+    return () => {
+      isMounted = false;
+      cleanupFnPromise.then((cleanup) => cleanup && cleanup());
+    };
+  }, [resourceType]);
+  return resource;
+};
+var sendJuggernautActionEvent = (actionType, payload) => {
+  if (typeof window === "undefined")
+    return;
+  if (IS_DEV_MODE) {
+    console.log(`[Juggernaut Action] ${actionType}`, payload);
+  }
+  if (!window.parent)
+    return;
+  window.parent.postMessage({
+    type: actionType,
+    payload
+  }, "*");
+};
+var useJuggernautJob = () => useJuggernautResource("job");
+var useJuggernautRecord = () => useJuggernautResource("record");
+var useJuggernautData = () => useJuggernautResource("data");
+var useJuggernautPlugin = () => useJuggernautResource("plugin");
+var useJuggernautProcess = () => useJuggernautResource("process");
+var useJuggernautActions = () => useJuggernautResource("actions");
+var useJuggernautSystem = () => useJuggernautResource("system");
+var FILE_EVENTS = {
+  GET_FILE: "juggernaut:file:get",
+  GET_JOB_FILE: "juggernaut:job:file:get",
+  UPLOAD_FILE: "juggernaut:file:upload"
+};
+var useJuggernautFileSystem = () => {
+  const requestFile = useCallback((actionType, payload) => {
+    return new Promise((resolve, reject) => {
+      if (IS_DEV_MODE) {
+        console.log(`[Dev Mode] Fetching file for ${actionType}`, payload);
+        const fileName = payload.fileId || payload.attachmentName || "demo.png";
+        fetch(`/demo-files/${fileName}`).then((res) => {
+          if (!res.ok)
+            throw new Error("Demo file not found");
+          return res.blob();
+        }).then((blob) => {
+          const file = new File([blob], fileName, { type: blob.type });
+          resolve(file);
+        }).catch((err) => {
+          console.warn("[Dev Mode] Could not load demo file:", err);
+          reject(err);
+        });
+        return;
+      }
+      if (typeof window === "undefined" || !window.parent) {
+        return reject(new Error("No parent window found"));
+      }
+      const requestId = crypto.randomUUID();
+      const handleResponse = (event) => {
+        const { requestId: resId, payload: responsePayload, error } = event.data || {};
+        if (resId === requestId) {
+          window.removeEventListener("message", handleResponse);
+          if (error) {
+            reject(new Error(error));
+          } else {
+            resolve(responsePayload);
+          }
+        }
+      };
+      window.addEventListener("message", handleResponse);
+      setTimeout(() => {
+        window.removeEventListener("message", handleResponse);
+        reject(new Error("File request timed out"));
+      }, 1e4);
+      window.parent.postMessage({
+        type: actionType,
+        requestId,
+        payload
+      }, "*");
+    });
+  }, []);
+  const getFile = useCallback((fileId) => {
+    if (!fileId)
+      return Promise.reject("No fileId provided");
+    return requestFile(FILE_EVENTS.GET_FILE, { fileId });
+  }, [requestFile]);
+  const getJobFile = useCallback((link, jobId = null) => {
+    if (!jobId || !link)
+      return Promise.reject("Missing jobId or link");
+    return requestFile(FILE_EVENTS.GET_JOB_FILE, { link, jobId });
+  }, [requestFile]);
+  return {
+    getFile,
+    getJobFile
+  };
+};
+// src/actions.jsx
+import { useEffect as useEffect2, useCallback as useCallback2, useRef as useRef2 } from "react";
+var ActionEvents = {
+  START_JOB: "start:job",
+  SCHEDULE_JOB: "schedule:job",
+  OPEN_RESOURCE: "open:resource",
+  START_PLUGIN: "start:plugin",
+  DATABASE_OPERATION: "database:operation",
+  TRIGGER_ACTION: "trigger:action",
+  CONTEXT_REQUEST: "juggernaut:context:request",
+  CONTEXT_RESPONSE: "juggernaut:context:response",
+  CONTEXT_UPDATE: "juggernaut:context:update"
+};
+var RESPONSE_TIMEOUT_MS = 5000;
+var useBridge = () => {
+  const pendingRequests = useRef2(new Map);
+  useEffect2(() => {
+    const handleMessage = (event) => {
+      const { requestId, payload, error } = event.data || {};
+      if (requestId && pendingRequests.current.has(requestId)) {
+        const { resolve, reject, timer } = pendingRequests.current.get(requestId);
+        clearTimeout(timer);
+        pendingRequests.current.delete(requestId);
+        if (error) {
+          reject(new Error(error));
+        } else {
+          resolve(payload);
+        }
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    return () => {
+      window.removeEventListener("message", handleMessage);
+      pendingRequests.current.forEach(({ reject, timer }) => {
+        clearTimeout(timer);
+        reject(new Error("Component unmounted"));
+      });
+      pendingRequests.current.clear();
+    };
+  }, []);
+  const sendEvent = useCallback2((actionType, payload = {}) => {
+    return new Promise((resolve, reject) => {
+      if (typeof window === "undefined" || !window?.parent) {
+        return reject(new Error("Parent window not found"));
+      }
+      const requestId = crypto.randomUUID ? crypto.randomUUID() : Date.now().toString();
+      const timer = setTimeout(() => {
+        if (pendingRequests.current.has(requestId)) {
+          pendingRequests.current.delete(requestId);
+          reject(new Error(`Request timed out after ${RESPONSE_TIMEOUT_MS}ms`));
+        }
+      }, RESPONSE_TIMEOUT_MS);
+      pendingRequests.current.set(requestId, { resolve, reject, timer });
+      window.parent.postMessage({
+        type: actionType,
+        requestId,
+        payload
+      }, "*");
+    });
+  }, []);
+  const startJob = useCallback2((processId, inputs, metadata = {}) => {
+    return sendEvent(ActionEvents.START_JOB, { processId, inputs, metadata });
+  }, [sendEvent]);
+  const scheduleJob = useCallback2((processId, inputs, schedule, metadata = {}) => {
+    return sendEvent(ActionEvents.SCHEDULE_JOB, { processId, inputs, schedule, metadata });
+  }, [sendEvent]);
+  const openResource = useCallback2((type, id, extra = {}) => {
+    return sendEvent(ActionEvents.OPEN_RESOURCE, { resourceType: type, resourceId: id, ...extra });
+  }, [sendEvent]);
+  const triggerAction = useCallback2((payload) => sendEvent(ActionEvents.TRIGGER_ACTION, payload), [sendEvent]);
+  const launchProcess = (id, options = {}) => openResource("process", id, options);
+  const launchJob = (id, options = {}) => openResource("job", id, options);
+  const launchPlugin = (id, options = {}) => openResource("plugin", id, options);
+  const launchDatabase = (id, options = {}) => openResource("database", id, options);
+  const launchRecord = (dbId, recordId, options = {}) => openResource("database:record", recordId, { database: dbId, ...options });
+  const startPlugin = useCallback2((payload) => sendEvent(ActionEvents.START_PLUGIN, payload), [sendEvent]);
+  const databaseOperation = useCallback2((payload) => sendEvent(ActionEvents.DATABASE_OPERATION, payload), [sendEvent]);
+  return {
+    startJob,
+    scheduleJob,
+    launchProcess,
+    launchJob,
+    launchPlugin,
+    launchDatabase,
+    launchRecord,
+    startPlugin,
+    databaseOperation,
+    triggerAction,
+    sendEvent
+  };
+};
+export {
+  useJuggernautSystem,
+  useJuggernautRecord,
+  useJuggernautProcess,
+  useJuggernautPlugin,
+  useJuggernautJob,
+  useJuggernautFileSystem,
+  useJuggernautData,
+  useJuggernautActions,
+  useBridge,
+  sendJuggernautActionEvent,
+  listenForJuggernautPlatformEvents,
+  ActionEvents
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@juggernautlabs/views",
+  "version": "0.0.1",
+  "description": "A way to build Juggernaut view templates using React.",
+  "type": "module",
+  "bin": {
+    "juggernauttemplates": "./dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "scripts": {
+    "test": "bun test --preload ./bun-setup.js",
+    "build": "bun run build:cli && bun run build:lib",
+    "build:cli": "bun build ./bin/cli.js --outfile dist/cli.js --target node --packages external",
+    "build:lib": "bun build ./src/index.js --outfile dist/index.js --target browser --packages external --format esm"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "platform",
+    "cloud",
+    "sdk",
+    "api",
+    "plugin",
+    "juggernaut",
+    "juggernautlabs",
+    "plugins",
+    "llm integration",
+    "mcp alternative",
+    "workflow automation",
+    "developer tools"
+  ],
+  "author": "Juggernaut Labs",
+  "license": "MIT",
+  "dependencies": {
+    "@vitejs/plugin-react": "^4.2.0",
+    "bun": "^1.3.4",
+    "cac": "^6.7.0",
+    "dotenv": "^17.2.3",
+    "json5": "^2.2.3",
+    "react": "^19.2.1",
+    "vite": "^6.0.0",
+    "vite-plugin-singlefile": "^2.0.0"
+  },
+  "devDependencies": {
+    "@happy-dom/global-registrator": "^20.0.11",
+    "@testing-library/react": "^16.3.0",
+    "@types/jest": "^30.0.0",
+    "happy-dom": "^20.0.11",
+    "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "ts-jest": "^29.4.6"
+  }
+}