@dovetail-v2/refine 0.0.31 → 0.0.32

package/dist/{MonacoYamlDiffEditor-b0ea1b12.js → MonacoYamlDiffEditor-6563a22b.js}

@@ -1,4 +1,4 @@
-import { j as jsxRuntimeExports } from "./index-01ce45aa.js";
+import { j as jsxRuntimeExports } from "./index-3d05d4c7.js";
 import * as monaco from "monaco-editor";
 import { useRef, useEffect } from "react";
 import "i18next";
@@ -10,8 +10,6 @@ import "js-yaml";
 import "lodash-es";
 import "sunflower-antd";
 import "@cloudtower/icons-react";
-import "monaco-yaml";
-import "react-dom";
 import "antd";
 import "k8s-api-provider";
 const MonacoYamlDiffEditor = (props) => {

package/dist/MonacoYamlEditor-a6e20f8c.js

@@ -0,0 +1,167 @@
+import { j as jsxRuntimeExports, c as cx_default, Y as YamlEditorStyle } from "./index-3d05d4c7.js";
+import * as monaco from "monaco-editor";
+import { setDiagnosticsOptions } from "monaco-yaml";
+import { useRef, useEffect } from "react";
+import ReactDOM from "react-dom";
+import "i18next";
+import "@refinedev/core";
+import "qs";
+import "react-router-dom";
+import "@cloudtower/eagle";
+import "js-yaml";
+import "lodash-es";
+import "sunflower-antd";
+import "@cloudtower/icons-react";
+import "antd";
+import "k8s-api-provider";
+const schemaMap = /* @__PURE__ */ new Map();
+const MonacoYamlEditor = (props) => {
+  const ref = useRef(null);
+  const instanceRef = useRef({ editor: null });
+  const {
+    defaultValue,
+    id,
+    height,
+    readOnly,
+    schema,
+    isScrollOnFocus,
+    onChange,
+    onValidate,
+    getInstance,
+    onEditorCreate,
+    onBlur
+  } = props;
+  const uri = id ? monaco.Uri.parse(`${id}.yaml`) : void 0;
+  useEffect(() => {
+    if (schema) {
+      schemaMap.set(id, {
+        // Id of the first schema
+        uri: String(uri),
+        // Associate with our model
+        fileMatch: uri ? [String(uri)] : [],
+        schema
+      });
+    }
+    const schemas = [...schemaMap.values()];
+    setDiagnosticsOptions({
+      enableSchemaRequest: false,
+      hover: true,
+      completion: true,
+      validate: true,
+      format: true,
+      isKubernetes: true,
+      schemas
+    });
+    const model = monaco.editor.createModel(defaultValue, "yaml", uri);
+    const editor = monaco.editor.create(ref.current, {
+      automaticLayout: true,
+      scrollBeyondLastLine: false,
+      model,
+      scrollbar: {
+        handleMouseWheel: !isScrollOnFocus
+      },
+      tabSize: 2,
+      readOnly,
+      autoIndent: {}.VITE_IS_TEST ? "none" : "advanced"
+    });
+    instanceRef.current.editor = editor;
+    getInstance == null ? void 0 : getInstance(editor);
+    onEditorCreate == null ? void 0 : onEditorCreate(editor);
+    return () => {
+      instanceRef.current.editor = null;
+      schemaMap.delete(id);
+      model.dispose();
+      editor.dispose();
+    };
+  }, [defaultValue, schema, id, readOnly, isScrollOnFocus, getInstance]);
+  useEffect(() => {
+    const editor = instanceRef.current.editor;
+    if (editor) {
+      const stop = editor.onDidChangeModelContent(() => {
+        ReactDOM.unstable_batchedUpdates(() => {
+          onChange == null ? void 0 : onChange(editor.getValue());
+        });
+      });
+      return () => {
+        stop.dispose();
+      };
+    }
+  }, [onChange, instanceRef.current.editor]);
+  useEffect(() => {
+    const editor = instanceRef.current.editor;
+    if (editor) {
+      const stop = monaco.editor.onDidChangeMarkers((uri2) => {
+        var _a;
+        const model = (_a = instanceRef.current.editor) == null ? void 0 : _a.getModel();
+        const currentEditorUri = model == null ? void 0 : model.uri;
+        if (model && uri2.toString() === (currentEditorUri == null ? void 0 : currentEditorUri.toString())) {
+          const marks = monaco.editor.getModelMarkers({ owner: "yaml", resource: currentEditorUri });
+          const yamlMarks = marks.filter((m) => m.source === "YAML");
+          const schemaMarks = marks.filter((m) => m.source !== "YAML");
+          const yamlValid = yamlMarks.length === 0;
+          const schemaValid = schemaMarks.length === 0;
+          onValidate == null ? void 0 : onValidate(yamlValid, schemaValid);
+          if (marks.some((mark) => {
+            var _a2;
+            return (_a2 = mark.source) == null ? void 0 : _a2.includes("yaml-schema");
+          })) {
+            monaco.editor.setModelMarkers(model, "yaml", marks.map((mark) => ({ ...mark, source: "", resource: {} })));
+          }
+        }
+      });
+      return () => {
+        stop.dispose();
+      };
+    }
+  }, [onValidate, instanceRef.current.editor]);
+  useEffect(() => {
+    const editor = instanceRef.current.editor;
+    if (editor) {
+      const stop = editor.onDidBlurEditorWidget(() => {
+        ReactDOM.unstable_batchedUpdates(() => {
+          onBlur == null ? void 0 : onBlur();
+        });
+      });
+      return () => {
+        stop.dispose();
+      };
+    }
+  }, [onBlur, instanceRef.current.editor]);
+  useEffect(() => {
+    const editor = instanceRef.current.editor;
+    const stops = [];
+    if (editor && isScrollOnFocus) {
+      stops.push(editor.onDidFocusEditorWidget(() => {
+        editor.updateOptions({
+          scrollbar: {
+            handleMouseWheel: true
+          }
+        });
+      }));
+      stops.push(editor.onDidBlurEditorWidget(() => {
+        editor.updateOptions({
+          scrollbar: {
+            handleMouseWheel: false
+          }
+        });
+      }));
+    }
+    return () => {
+      stops.forEach((stop) => stop.dispose());
+    };
+  }, [instanceRef.current.editor, isScrollOnFocus]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "div",
+    {
+      ref,
+      className: cx_default(YamlEditorStyle, props.className),
+      style: {
+        width: "100%",
+        height: height || "500px"
+      }
+    }
+  );
+};
+export {
+  MonacoYamlEditor as default
+};