@dovetail-v2/refine 0.2.2-alpha.0 → 0.2.3-alpha.0

package/dist/{MonacoYamlDiffEditor-fe64524b.js → MonacoYamlDiffEditor-4d765c36.js}

@@ -1,6 +1,7 @@
-import { j as jsxRuntimeExports } from "./index-d00a6dbe.js";
+import { j as jsxRuntimeExports } from "./index-49e0db41.js";
 import * as monaco from "monaco-editor";
 import { useRef, useEffect } from "react";
+import "dayjs";
 import "i18next";
 import "@refinedev/core";
 import "qs";
@@ -9,9 +10,18 @@ import "@cloudtower/eagle";
 import "@cloudtower/icons-react";
 import "lodash-es";
 import "js-yaml";
+import "usehooks-ts";
 import "k8s-api-provider";
-import "monaco-yaml";
-import "react-dom";
+import "@patternfly/react-log-viewer";
+import "@xterm/addon-canvas";
+import "@xterm/addon-fit";
+import "@xterm/addon-search";
+import "@xterm/addon-web-links";
+import "@xterm/addon-webgl";
+import "@xterm/xterm";
+import "copy-to-clipboard";
+import "buffer";
+import "react-hook-form";
 import "sunflower-antd";
 import "antd";
 const MonacoYamlDiffEditor = (props) => {

package/dist/MonacoYamlEditor-267b3405.js

@@ -0,0 +1,196 @@
+import { j as jsxRuntimeExports, c as cx_default, Y as YamlEditorStyle } from "./index-49e0db41.js";
+import * as monaco from "monaco-editor";
+import { setDiagnosticsOptions } from "monaco-yaml";
+import { useRef, useEffect } from "react";
+import ReactDOM from "react-dom";
+import "dayjs";
+import "i18next";
+import "@refinedev/core";
+import "qs";
+import "react-router-dom";
+import "@cloudtower/eagle";
+import "@cloudtower/icons-react";
+import "lodash-es";
+import "js-yaml";
+import "usehooks-ts";
+import "k8s-api-provider";
+import "@patternfly/react-log-viewer";
+import "@xterm/addon-canvas";
+import "@xterm/addon-fit";
+import "@xterm/addon-search";
+import "@xterm/addon-web-links";
+import "@xterm/addon-webgl";
+import "@xterm/xterm";
+import "copy-to-clipboard";
+import "buffer";
+import "react-hook-form";
+import "sunflower-antd";
+import "antd";
+const MonacoYamlEditor = (props) => {
+  const ref = useRef(null);
+  const instanceRef = useRef({
+    editor: null
+  });
+  const {
+    defaultValue,
+    id,
+    height,
+    readOnly,
+    schemas,
+    isScrollOnFocus,
+    onChange,
+    onValidate,
+    getInstance,
+    onEditorCreate,
+    onBlur
+  } = props;
+  const uri = id ? monaco.Uri.parse(`${id}.yaml`) : void 0;
+  useEffect(() => {
+    if (!window._MonacoSchemaMap) {
+      window._MonacoSchemaMap = /* @__PURE__ */ new Map();
+    }
+    window._MonacoSchemaMap.set(id || "", {
+      // Id of the first schema
+      uri: String(uri),
+      // Associate with our model
+      fileMatch: [String(uri)],
+      schema: {
+        oneOf: schemas || [{ type: "object" }]
+      }
+    });
+    const finalSchemas = [...window._MonacoSchemaMap.values()];
+    setDiagnosticsOptions({
+      enableSchemaRequest: false,
+      validate: true,
+      format: true,
+      isKubernetes: true,
+      schemas: finalSchemas
+    });
+    const model = monaco.editor.createModel(defaultValue, "yaml", uri);
+    const editor = monaco.editor.create(ref.current, {
+      automaticLayout: true,
+      scrollBeyondLastLine: false,
+      model,
+      scrollbar: {
+        handleMouseWheel: !isScrollOnFocus,
+        alwaysConsumeMouseWheel: false
+        // https://github.com/microsoft/monaco-editor/issues/2007
+      },
+      tabSize: 2,
+      lineNumbersMinChars: 7,
+      readOnly,
+      autoIndent: {}.VITE_IS_TEST ? "none" : "advanced",
+      theme: "vs"
+    });
+    instanceRef.current.editor = editor;
+    getInstance == null ? void 0 : getInstance(editor);
+    onEditorCreate == null ? void 0 : onEditorCreate(editor);
+    return () => {
+      instanceRef.current.editor = null;
+      window._MonacoSchemaMap.delete(id || "");
+      model.dispose();
+      editor.dispose();
+    };
+  }, [id, schemas, 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]);
+  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]);
+  useEffect(() => {
+    const editor = instanceRef.current.editor;
+    if (editor) {
+      const stop = editor.onDidBlurEditorWidget(() => {
+        ReactDOM.unstable_batchedUpdates(() => {
+          onBlur == null ? void 0 : onBlur();
+        });
+      });
+      return () => {
+        stop.dispose();
+      };
+    }
+  }, [onBlur]);
+  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());
+    };
+  }, [isScrollOnFocus]);
+  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+    "div",
+    {
+      ref,
+      className: cx_default(YamlEditorStyle, props.className),
+      style: {
+        width: "100%",
+        height: height || "500px"
+      }
+    }
+  );
+};
+export {
+  MonacoYamlEditor as default
+};