@djangocfg/ui-tools 2.1.238 → 2.1.240

package/dist/index.cjs

@@ -905,6 +905,730 @@ function CronSchedulerFallback() {
 }
 chunkWGEGR3DF_cjs.__name(CronSchedulerFallback, "CronSchedulerFallback");
 
+// src/tools/CodeEditor/workers/setup.ts
+var isSetup = false;
+function setupMonacoWorkers(getWorker) {
+  if (isSetup || typeof window === "undefined") return;
+  if (getWorker) {
+    self.MonacoEnvironment = {
+      getWorker: /* @__PURE__ */ chunkWGEGR3DF_cjs.__name((_workerId, label) => getWorker(label), "getWorker")
+    };
+  }
+  isSetup = true;
+}
+chunkWGEGR3DF_cjs.__name(setupMonacoWorkers, "setupMonacoWorkers");
+
+// src/tools/CodeEditor/hooks/useMonaco.ts
+function useMonaco() {
+  const [monaco, setMonaco] = React3.useState(null);
+  const [isLoading, setIsLoading] = React3.useState(true);
+  const [error, setError] = React3.useState(null);
+  React3.useEffect(() => {
+    let mounted = true;
+    async function loadMonaco() {
+      try {
+        setupMonacoWorkers();
+        const monacoModule = await import('monaco-editor');
+        if (mounted) {
+          setMonaco(monacoModule);
+          setIsLoading(false);
+        }
+      } catch (err) {
+        if (mounted) {
+          setError(err instanceof Error ? err : new Error("Failed to load Monaco Editor"));
+          setIsLoading(false);
+        }
+      }
+    }
+    chunkWGEGR3DF_cjs.__name(loadMonaco, "loadMonaco");
+    loadMonaco();
+    return () => {
+      mounted = false;
+    };
+  }, []);
+  return { monaco, isLoading, error };
+}
+chunkWGEGR3DF_cjs.__name(useMonaco, "useMonaco");
+function useEditorTheme(monaco, themeOverride) {
+  const appTheme = hooks.useResolvedTheme();
+  const registered = React3.useRef(false);
+  React3.useEffect(() => {
+    if (!monaco || registered.current) return;
+    try {
+      const colors = _readCSSColors();
+      monaco.editor.defineTheme("app-dark", {
+        base: "vs-dark",
+        inherit: true,
+        rules: [
+          { token: "comment", foreground: "6A9955", fontStyle: "italic" },
+          { token: "keyword", foreground: "C586C0" },
+          { token: "string", foreground: "CE9178" },
+          { token: "number", foreground: "B5CEA8" },
+          { token: "type", foreground: "4EC9B0" },
+          { token: "function", foreground: "DCDCAA" },
+          { token: "variable", foreground: "9CDCFE" }
+        ],
+        colors: {
+          "editor.background": colors.background,
+          "editor.foreground": colors.foreground,
+          "editor.lineHighlightBackground": colors.lineHighlight,
+          "editor.selectionBackground": colors.selection,
+          "editorCursor.foreground": colors.foreground,
+          "editorLineNumber.foreground": colors.mutedForeground,
+          "editorWidget.background": colors.card,
+          "editorWidget.border": colors.border,
+          "input.background": colors.card,
+          "dropdown.background": colors.card
+        }
+      });
+      monaco.editor.defineTheme("app-light", {
+        base: "vs",
+        inherit: true,
+        rules: [
+          { token: "comment", foreground: "008000", fontStyle: "italic" },
+          { token: "keyword", foreground: "AF00DB" },
+          { token: "string", foreground: "A31515" },
+          { token: "number", foreground: "098658" },
+          { token: "type", foreground: "267F99" },
+          { token: "function", foreground: "795E26" },
+          { token: "variable", foreground: "001080" }
+        ],
+        colors: {
+          "editor.background": colors.backgroundLight,
+          "editor.foreground": colors.foregroundLight,
+          "editor.lineHighlightBackground": colors.lineHighlightLight,
+          "editor.selectionBackground": colors.selectionLight,
+          "editorLineNumber.foreground": colors.mutedForegroundLight,
+          "editorWidget.background": colors.cardLight,
+          "editorWidget.border": colors.borderLight
+        }
+      });
+      registered.current = true;
+    } catch {
+    }
+  }, [monaco]);
+  if (themeOverride) return themeOverride;
+  if (registered.current) {
+    return appTheme === "dark" ? "app-dark" : "app-light";
+  }
+  return appTheme === "dark" ? "vs-dark" : "vs";
+}
+chunkWGEGR3DF_cjs.__name(useEditorTheme, "useEditorTheme");
+function _readCSSColors() {
+  const get = /* @__PURE__ */ chunkWGEGR3DF_cjs.__name((varName) => {
+    if (typeof document === "undefined") return "";
+    return getComputedStyle(document.documentElement).getPropertyValue(varName).trim();
+  }, "get");
+  const hslToHex2 = /* @__PURE__ */ chunkWGEGR3DF_cjs.__name((hsl) => {
+    if (!hsl) return "";
+    const parts = hsl.split(/\s+/).map((s2) => parseFloat(s2.replace("%", "")));
+    if (parts.length < 3 || parts.some(isNaN)) return "";
+    const [h, s, l] = [parts[0], parts[1] / 100, parts[2] / 100];
+    const a = s * Math.min(l, 1 - l);
+    const f = /* @__PURE__ */ chunkWGEGR3DF_cjs.__name((n) => {
+      const k = (n + h / 30) % 12;
+      const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+      return Math.round(255 * color).toString(16).padStart(2, "0");
+    }, "f");
+    return `#${f(0)}${f(8)}${f(4)}`;
+  }, "hslToHex");
+  const background = hslToHex2(get("--background")) || "#0a0a0a";
+  const foreground = hslToHex2(get("--foreground")) || "#f5f5f5";
+  const card = hslToHex2(get("--card")) || "#141414";
+  const border = hslToHex2(get("--border")) || "#262626";
+  const mutedForeground = hslToHex2(get("--muted-foreground")) || "#858585";
+  const lineHighlight = _adjustBrightness(background, 10);
+  const primary = hslToHex2(get("--primary"));
+  const selection = primary ? _adjustBrightness(primary, -40) : "#264F78";
+  return {
+    background,
+    foreground,
+    card,
+    border,
+    mutedForeground,
+    lineHighlight,
+    selection,
+    // Light variants
+    backgroundLight: "#ffffff",
+    foregroundLight: "#1a1a1a",
+    cardLight: "#ffffff",
+    borderLight: "#e5e5e5",
+    mutedForegroundLight: "#737373",
+    lineHighlightLight: "#f5f5f5",
+    selectionLight: "#ADD6FF"
+  };
+}
+chunkWGEGR3DF_cjs.__name(_readCSSColors, "_readCSSColors");
+function _adjustBrightness(hex, amount) {
+  const num = parseInt(hex.replace("#", ""), 16);
+  const r = Math.min(255, Math.max(0, (num >> 16 & 255) + amount));
+  const g = Math.min(255, Math.max(0, (num >> 8 & 255) + amount));
+  const b = Math.min(255, Math.max(0, (num & 255) + amount));
+  return `#${(r << 16 | g << 8 | b).toString(16).padStart(6, "0")}`;
+}
+chunkWGEGR3DF_cjs.__name(_adjustBrightness, "_adjustBrightness");
+var Editor = React3.forwardRef(/* @__PURE__ */ chunkWGEGR3DF_cjs.__name(function Editor2({
+  value = "",
+  language = "plaintext",
+  onChange,
+  onMount,
+  options = {},
+  className = "",
+  height = "100%",
+  width = "100%",
+  autoHeight = false,
+  minHeight = 100,
+  maxHeight = 600
+}, ref) {
+  const containerRef = React3.useRef(null);
+  const editorRef = React3.useRef(null);
+  const { monaco, isLoading } = useMonaco();
+  const resolvedTheme = useEditorTheme(monaco, options.theme);
+  const [contentHeight, setContentHeight] = React3.useState(null);
+  const updateContentHeight = React3.useCallback((editor) => {
+    if (!autoHeight) return;
+    const h = editor.getContentHeight();
+    setContentHeight(Math.min(Math.max(h, minHeight), maxHeight));
+  }, [autoHeight, minHeight, maxHeight]);
+  const isInternalChangeRef = React3.useRef(false);
+  React3.useImperativeHandle(ref, () => ({
+    getEditor: /* @__PURE__ */ chunkWGEGR3DF_cjs.__name(() => editorRef.current, "getEditor"),
+    getValue: /* @__PURE__ */ chunkWGEGR3DF_cjs.__name(() => editorRef.current?.getValue() || "", "getValue"),
+    setValue: /* @__PURE__ */ chunkWGEGR3DF_cjs.__name((val) => editorRef.current?.setValue(val), "setValue"),
+    focus: /* @__PURE__ */ chunkWGEGR3DF_cjs.__name(() => editorRef.current?.focus(), "focus")
+  }));
+  React3.useEffect(() => {
+    if (!monaco || !containerRef.current || editorRef.current) return;
+    const editor = monaco.editor.create(containerRef.current, {
+      value,
+      language,
+      theme: resolvedTheme,
+      fontSize: options.fontSize || 14,
+      fontFamily: options.fontFamily || "'Fira Code', 'Consolas', monospace",
+      tabSize: options.tabSize || 2,
+      insertSpaces: options.insertSpaces !== false,
+      wordWrap: options.wordWrap || "on",
+      minimap: { enabled: options.minimap !== false },
+      lineNumbers: options.lineNumbers || "on",
+      readOnly: options.readOnly || false,
+      automaticLayout: true,
+      scrollBeyondLastLine: autoHeight ? false : false,
+      scrollbar: autoHeight ? { vertical: "hidden", horizontal: "auto" } : void 0,
+      overviewRulerLanes: autoHeight ? 0 : void 0,
+      padding: { top: 16, bottom: 16 },
+      renderLineHighlight: "all",
+      cursorBlinking: "smooth",
+      cursorSmoothCaretAnimation: "on",
+      smoothScrolling: true,
+      bracketPairColorization: { enabled: true },
+      guides: {
+        bracketPairs: true,
+        indentation: true
+      }
+    });
+    editorRef.current = editor;
+    if (onChange) {
+      editor.onDidChangeModelContent(() => {
+        isInternalChangeRef.current = true;
+        onChange(editor.getValue());
+      });
+    }
+    if (autoHeight) {
+      editor.onDidContentSizeChange(() => updateContentHeight(editor));
+      updateContentHeight(editor);
+    }
+    onMount?.(editor);
+    return () => {
+      editor.dispose();
+      editorRef.current = null;
+    };
+  }, [monaco]);
+  React3.useEffect(() => {
+    const editor = editorRef.current;
+    if (!editor) return;
+    if (isInternalChangeRef.current) {
+      isInternalChangeRef.current = false;
+      return;
+    }
+    const currentValue = editor.getValue();
+    if (value !== currentValue) {
+      const position = editor.getPosition();
+      const selections = editor.getSelections();
+      editor.setValue(value);
+      if (position) {
+        editor.setPosition(position);
+      }
+      if (selections && selections.length > 0) {
+        editor.setSelections(selections);
+      }
+    }
+  }, [value]);
+  React3.useEffect(() => {
+    const editor = editorRef.current;
+    if (!editor || !monaco) return;
+    const model = editor.getModel();
+    if (model) {
+      monaco.editor.setModelLanguage(model, language);
+    }
+  }, [language, monaco]);
+  React3.useEffect(() => {
+    const editor = editorRef.current;
+    if (!editor) return;
+    editor.updateOptions({
+      theme: resolvedTheme,
+      fontSize: options.fontSize,
+      readOnly: options.readOnly,
+      minimap: { enabled: options.minimap !== false },
+      wordWrap: options.wordWrap,
+      lineNumbers: options.lineNumbers
+    });
+  }, [options, resolvedTheme]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className,
+        style: {
+          width,
+          height,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          backgroundColor: "#1e1e1e",
+          color: "#666"
+        },
+        children: "Loading editor..."
+      }
+    );
+  }
+  const resolvedHeight = autoHeight && contentHeight != null ? contentHeight : height;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      style: {
+        width,
+        height: resolvedHeight,
+        ...autoHeight && { minHeight, maxHeight, overflow: "hidden" }
+      }
+    }
+  );
+}, "Editor"));
+function DiffEditor({
+  original,
+  modified,
+  language = "plaintext",
+  options = {},
+  className = "",
+  height = "100%"
+}) {
+  const containerRef = React3.useRef(null);
+  const editorRef = React3.useRef(null);
+  const { monaco, isLoading } = useMonaco();
+  const resolvedTheme = useEditorTheme(monaco, options.theme);
+  React3.useEffect(() => {
+    if (!monaco || !containerRef.current || editorRef.current) return;
+    const editor = monaco.editor.createDiffEditor(containerRef.current, {
+      theme: resolvedTheme,
+      fontSize: options.fontSize || 14,
+      fontFamily: options.fontFamily || "'Fira Code', 'Consolas', monospace",
+      readOnly: true,
+      automaticLayout: true,
+      renderSideBySide: true,
+      scrollBeyondLastLine: false,
+      minimap: { enabled: false }
+    });
+    const originalModel = monaco.editor.createModel(original, language);
+    const modifiedModel = monaco.editor.createModel(modified, language);
+    editor.setModel({
+      original: originalModel,
+      modified: modifiedModel
+    });
+    editorRef.current = editor;
+    return () => {
+      originalModel.dispose();
+      modifiedModel.dispose();
+      editor.dispose();
+      editorRef.current = null;
+    };
+  }, [monaco]);
+  React3.useEffect(() => {
+    const editor = editorRef.current;
+    if (!editor || !monaco) return;
+    const model = editor.getModel();
+    if (model) {
+      model.original.setValue(original);
+      model.modified.setValue(modified);
+    }
+  }, [original, modified, monaco]);
+  React3.useEffect(() => {
+    const editor = editorRef.current;
+    if (!editor || !monaco) return;
+    const model = editor.getModel();
+    if (model) {
+      monaco.editor.setModelLanguage(model.original, language);
+      monaco.editor.setModelLanguage(model.modified, language);
+    }
+  }, [language, monaco]);
+  if (isLoading) {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "div",
+      {
+        className,
+        style: {
+          width: "100%",
+          height,
+          display: "flex",
+          alignItems: "center",
+          justifyContent: "center",
+          backgroundColor: "#1e1e1e",
+          color: "#666"
+        },
+        children: "Loading diff editor..."
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      style: {
+        width: "100%",
+        height
+      }
+    }
+  );
+}
+chunkWGEGR3DF_cjs.__name(DiffEditor, "DiffEditor");
+
+// src/tools/CodeEditor/lib/languages.ts
+var LANGUAGE_MAP = {
+  // Web
+  ".html": "html",
+  ".htm": "html",
+  ".xhtml": "html",
+  ".vue": "html",
+  ".svelte": "html",
+  // CSS
+  ".css": "css",
+  ".scss": "scss",
+  ".sass": "scss",
+  ".less": "less",
+  // JavaScript/TypeScript
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "javascript",
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  // Data formats
+  ".json": "json",
+  ".jsonc": "json",
+  ".json5": "json",
+  ".yaml": "yaml",
+  ".yml": "yaml",
+  ".toml": "ini",
+  ".xml": "xml",
+  ".svg": "xml",
+  ".xsl": "xml",
+  ".xsd": "xml",
+  // Markdown & Documentation
+  ".md": "markdown",
+  ".mdx": "markdown",
+  ".markdown": "markdown",
+  ".rst": "restructuredtext",
+  ".txt": "plaintext",
+  ".text": "plaintext",
+  // Programming languages
+  ".py": "python",
+  ".pyw": "python",
+  ".pyi": "python",
+  ".rb": "ruby",
+  ".rake": "ruby",
+  ".gemspec": "ruby",
+  ".php": "php",
+  ".phtml": "php",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".scala": "scala",
+  ".go": "go",
+  ".rs": "rust",
+  ".swift": "swift",
+  ".c": "c",
+  ".h": "c",
+  ".cpp": "cpp",
+  ".cc": "cpp",
+  ".cxx": "cpp",
+  ".hpp": "cpp",
+  ".hxx": "cpp",
+  ".cs": "csharp",
+  ".fs": "fsharp",
+  ".fsx": "fsharp",
+  ".vb": "vb",
+  ".lua": "lua",
+  ".r": "r",
+  ".R": "r",
+  ".m": "objective-c",
+  ".mm": "objective-c",
+  ".pl": "perl",
+  ".pm": "perl",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".hrl": "erlang",
+  ".clj": "clojure",
+  ".cljs": "clojure",
+  ".cljc": "clojure",
+  ".hs": "haskell",
+  ".lhs": "haskell",
+  ".ml": "fsharp",
+  ".mli": "fsharp",
+  ".dart": "dart",
+  ".groovy": "groovy",
+  ".gradle": "groovy",
+  ".jl": "julia",
+  // Shell & Scripts
+  ".sh": "shell",
+  ".bash": "shell",
+  ".zsh": "shell",
+  ".fish": "shell",
+  ".ps1": "powershell",
+  ".psm1": "powershell",
+  ".psd1": "powershell",
+  ".bat": "bat",
+  ".cmd": "bat",
+  // Config files
+  ".ini": "ini",
+  ".cfg": "ini",
+  ".conf": "ini",
+  ".properties": "ini",
+  ".env": "ini",
+  ".gitignore": "ini",
+  ".gitattributes": "ini",
+  ".editorconfig": "ini",
+  ".npmrc": "ini",
+  // Database
+  ".sql": "sql",
+  ".mysql": "mysql",
+  ".pgsql": "pgsql",
+  ".plsql": "plsql",
+  ".redis": "redis",
+  // Templates
+  ".hbs": "handlebars",
+  ".handlebars": "handlebars",
+  ".mustache": "handlebars",
+  ".ejs": "html",
+  ".pug": "pug",
+  ".jade": "pug",
+  ".twig": "twig",
+  ".liquid": "liquid",
+  // GraphQL
+  ".graphql": "graphql",
+  ".gql": "graphql",
+  // Docker
+  ".dockerfile": "dockerfile",
+  // Other
+  ".diff": "diff",
+  ".patch": "diff",
+  ".log": "log",
+  ".tex": "latex",
+  ".cls": "latex",
+  ".sty": "latex",
+  ".proto": "protobuf",
+  ".sol": "sol",
+  ".asm": "mips",
+  ".s": "mips",
+  ".wasm": "wasm"
+};
+var FILENAME_MAP = {
+  Dockerfile: "dockerfile",
+  "docker-compose.yml": "yaml",
+  "docker-compose.yaml": "yaml",
+  Makefile: "makefile",
+  makefile: "makefile",
+  Gemfile: "ruby",
+  Rakefile: "ruby",
+  Jenkinsfile: "groovy",
+  Vagrantfile: "ruby",
+  ".bashrc": "shell",
+  ".bash_profile": "shell",
+  ".zshrc": "shell",
+  ".profile": "shell",
+  ".vimrc": "plaintext",
+  ".gitconfig": "ini",
+  ".htaccess": "ini",
+  "nginx.conf": "ini",
+  "package.json": "json",
+  "tsconfig.json": "json",
+  "jsconfig.json": "json",
+  ".prettierrc": "json",
+  ".eslintrc": "json",
+  "composer.json": "json",
+  "Cargo.toml": "ini",
+  "go.mod": "go",
+  "go.sum": "plaintext",
+  "requirements.txt": "plaintext",
+  "pyproject.toml": "ini",
+  "setup.py": "python",
+  "setup.cfg": "ini"
+};
+function getLanguageByFilename(filename) {
+  if (FILENAME_MAP[filename]) {
+    return FILENAME_MAP[filename];
+  }
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot === -1) {
+    return "plaintext";
+  }
+  const extension = filename.slice(lastDot).toLowerCase();
+  return LANGUAGE_MAP[extension] || "plaintext";
+}
+chunkWGEGR3DF_cjs.__name(getLanguageByFilename, "getLanguageByFilename");
+var EditorContext = React3.createContext(null);
+function useEditorContext() {
+  const context = React3.useContext(EditorContext);
+  if (!context) {
+    throw new Error("useEditorContext must be used within EditorProvider");
+  }
+  return context;
+}
+chunkWGEGR3DF_cjs.__name(useEditorContext, "useEditorContext");
+function EditorProvider({ children, onSave }) {
+  const { monaco } = useMonaco();
+  const [editor, setEditor] = React3.useState(null);
+  const [openFiles, setOpenFiles] = React3.useState([]);
+  const [activeFilePath, setActiveFilePath] = React3.useState(null);
+  const activeFile = React3.useMemo(
+    () => openFiles.find((f) => f.path === activeFilePath) || null,
+    [openFiles, activeFilePath]
+  );
+  const openFile = React3.useCallback(
+    (path, content, language) => {
+      setOpenFiles((files) => {
+        const existing = files.find((f) => f.path === path);
+        if (existing) {
+          return files;
+        }
+        const basename = path.split("/").pop() || path;
+        const detectedLanguage = language || getLanguageByFilename(basename);
+        const newFile = {
+          path,
+          content,
+          language: detectedLanguage,
+          isDirty: false
+        };
+        return [...files, newFile];
+      });
+      setActiveFilePath(path);
+    },
+    []
+  );
+  const closeFile = React3.useCallback(
+    (path) => {
+      setOpenFiles((files) => {
+        const index = files.findIndex((f) => f.path === path);
+        if (index === -1) return files;
+        const newFiles = files.filter((f) => f.path !== path);
+        if (activeFilePath === path && newFiles.length > 0) {
+          const newIndex = Math.min(index, newFiles.length - 1);
+          setActiveFilePath(newFiles[newIndex].path);
+        } else if (newFiles.length === 0) {
+          setActiveFilePath(null);
+        }
+        return newFiles;
+      });
+    },
+    [activeFilePath]
+  );
+  const setActiveFile = React3.useCallback((path) => {
+    setActiveFilePath(path);
+  }, []);
+  const updateContent = React3.useCallback((path, content) => {
+    setOpenFiles(
+      (files) => files.map(
+        (f) => f.path === path ? { ...f, content, isDirty: true } : f
+      )
+    );
+  }, []);
+  const saveFile = React3.useCallback(
+    async (path) => {
+      const file = openFiles.find((f) => f.path === path);
+      if (!file) return;
+      if (onSave) {
+        await onSave(path, file.content);
+      }
+      setOpenFiles(
+        (files) => files.map(
+          (f) => f.path === path ? { ...f, isDirty: false } : f
+        )
+      );
+    },
+    [openFiles, onSave]
+  );
+  const isDirty = React3.useCallback(
+    (path) => {
+      const file = openFiles.find((f) => f.path === path);
+      return file?.isDirty || false;
+    },
+    [openFiles]
+  );
+  const getContent = React3.useCallback(
+    (path) => {
+      const file = openFiles.find((f) => f.path === path);
+      return file?.content || null;
+    },
+    [openFiles]
+  );
+  const getFile = React3.useCallback(
+    (path) => {
+      return openFiles.find((f) => f.path === path) || null;
+    },
+    [openFiles]
+  );
+  const value = {
+    openFiles,
+    activeFile,
+    monaco,
+    editor,
+    isReady: monaco !== null && editor !== null,
+    openFile,
+    closeFile,
+    setActiveFile,
+    updateContent,
+    saveFile,
+    isDirty,
+    getContent,
+    getFile
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(EditorContext.Provider, { value, children });
+}
+chunkWGEGR3DF_cjs.__name(EditorProvider, "EditorProvider");
+function useEditor() {
+  const [editor, setEditorState] = React3.useState(null);
+  const setEditor = React3.useCallback((editorInstance) => {
+    setEditorState(editorInstance);
+  }, []);
+  return {
+    editor,
+    isReady: editor !== null,
+    setEditor
+  };
+}
+chunkWGEGR3DF_cjs.__name(useEditor, "useEditor");
+function useLanguage(filename) {
+  return React3.useMemo(() => {
+    if (!filename) return "plaintext";
+    const basename = filename.split("/").pop() || filename;
+    return getLanguageByFilename(basename);
+  }, [filename]);
+}
+chunkWGEGR3DF_cjs.__name(useLanguage, "useLanguage");
+
 Object.defineProperty(exports, "AudioReactiveCover", {
   enumerable: true,
   get: function () { return chunkYZX6FH3H_cjs.AudioReactiveCover; }
@@ -1307,6 +2031,9 @@ Object.defineProperty(exports, "useLottie", {
 });
 exports.CardLoadingFallback = CardLoadingFallback;
 exports.CronScheduler = CronScheduler;
+exports.DiffEditor = DiffEditor;
+exports.Editor = Editor;
+exports.EditorProvider = EditorProvider;
 exports.LazyCronScheduler = LazyCronScheduler;
 exports.LazyHybridAudioPlayer = LazyHybridAudioPlayer;
 exports.LazyHybridCompactPlayer = LazyHybridCompactPlayer;
@@ -1331,5 +2058,9 @@ exports.OpenapiViewer = OpenapiViewer_default;
 exports.Spinner = Spinner;
 exports.createLazyComponent = createLazyComponent;
 exports.useCollapsibleContent = useCollapsibleContent;
+exports.useEditor = useEditor;
+exports.useEditorContext = useEditorContext;
+exports.useLanguage = useLanguage;
+exports.useMonaco = useMonaco;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map