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

package/dist/MonacoYamlDiffEditor-7a07db88.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("./common-1eb43414.cjs");
+const monaco = require("monaco-editor");
+const React = require("react");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const monaco__namespace = /* @__PURE__ */ _interopNamespaceDefault(monaco);
+const MonacoYamlDiffEditor = (props) => {
+  const ref = React.useRef(null);
+  const { origin, modified, id, height } = props;
+  React.useEffect(() => {
+    const originalUri = id ? monaco__namespace.Uri.parse(`${id}_original.yaml`) : void 0;
+    const modifiedUri = id ? monaco__namespace.Uri.parse(`${id}_modified.yaml`) : void 0;
+    const originalModel = monaco__namespace.editor.createModel(origin, "yaml", originalUri);
+    const modifiedModel = monaco__namespace.editor.createModel(modified, "yaml", modifiedUri);
+    const diffEditor = monaco__namespace.editor.createDiffEditor(ref.current, {
+      renderSideBySide: true,
+      originalEditable: false,
+      readOnly: true,
+      ignoreTrimWhitespace: false,
+      scrollBeyondLastLine: false
+    });
+    diffEditor.setModel({
+      original: originalModel,
+      modified: modifiedModel
+    });
+    return () => {
+      diffEditor.dispose();
+      originalModel.dispose();
+      modifiedModel.dispose();
+    };
+  }, [modified, origin, id]);
+  return /* @__PURE__ */ common.jsxRuntimeExports.jsx(
+    "div",
+    {
+      ref,
+      style: {
+        width: "100%",
+        height: height || "500px"
+      }
+    }
+  );
+};
+exports.default = MonacoYamlDiffEditor;

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

@@ -1,29 +1,6 @@
-import { j as jsxRuntimeExports } from "./index-49e0db41.js";
+import { j as jsxRuntimeExports } from "./common-feae5742.js";
 import * as monaco from "monaco-editor";
 import { useRef, useEffect } from "react";
-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 MonacoYamlDiffEditor = (props) => {
   const ref = useRef(null);
   const { origin, modified, id, height } = props;

package/dist/MonacoYamlEditor-bc33cd45.cjs

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("./common-1eb43414.cjs");
+const monaco = require("monaco-editor");
+const monacoYaml = require("monaco-yaml");
+const React = require("react");
+const ReactDOM = require("react-dom");
+const refine = require("./index-ee8ac828.cjs");
+require("dayjs");
+require("i18next");
+require("@refinedev/core");
+require("qs");
+require("react-router-dom");
+require("@cloudtower/eagle");
+require("@cloudtower/icons-react");
+require("lodash-es");
+require("js-yaml");
+require("usehooks-ts");
+require("k8s-api-provider");
+require("@patternfly/react-log-viewer");
+require("react-hook-form");
+require("sunflower-antd");
+require("antd");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const monaco__namespace = /* @__PURE__ */ _interopNamespaceDefault(monaco);
+const MonacoYamlEditor = (props) => {
+  const ref = React.useRef(null);
+  const instanceRef = React.useRef({
+    editor: null
+  });
+  const {
+    defaultValue,
+    id,
+    height,
+    readOnly,
+    schemas,
+    isScrollOnFocus,
+    onChange,
+    onValidate,
+    getInstance,
+    onEditorCreate,
+    onBlur
+  } = props;
+  const uri = id ? monaco__namespace.Uri.parse(`${id}.yaml`) : void 0;
+  React.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()];
+    monacoYaml.setDiagnosticsOptions({
+      enableSchemaRequest: false,
+      validate: true,
+      format: true,
+      isKubernetes: true,
+      schemas: finalSchemas
+    });
+    const model = monaco__namespace.editor.createModel(defaultValue, "yaml", uri);
+    const editor = monaco__namespace.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]);
+  React.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]);
+  React.useEffect(() => {
+    const editor = instanceRef.current.editor;
+    if (editor) {
+      const stop = monaco__namespace.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__namespace.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__namespace.editor.setModelMarkers(
+              model,
+              "yaml",
+              marks.map((mark) => ({ ...mark, source: "", resource: {} }))
+            );
+          }
+        }
+      });
+      return () => {
+        stop.dispose();
+      };
+    }
+  }, [onValidate]);
+  React.useEffect(() => {
+    const editor = instanceRef.current.editor;
+    if (editor) {
+      const stop = editor.onDidBlurEditorWidget(() => {
+        ReactDOM.unstable_batchedUpdates(() => {
+          onBlur == null ? void 0 : onBlur();
+        });
+      });
+      return () => {
+        stop.dispose();
+      };
+    }
+  }, [onBlur]);
+  React.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__ */ common.jsxRuntimeExports.jsx(
+    "div",
+    {
+      ref,
+      className: common.cx_default(refine.YamlEditorStyle, props.className),
+      style: {
+        width: "100%",
+        height: height || "500px"
+      }
+    }
+  );
+};
+exports.default = MonacoYamlEditor;

package/dist/{MonacoYamlEditor-267b3405.js → MonacoYamlEditor-bc70e03e.js}

@@ -1,8 +1,9 @@
-import { j as jsxRuntimeExports, c as cx_default, Y as YamlEditorStyle } from "./index-49e0db41.js";
+import { j as jsxRuntimeExports, c as cx_default } from "./common-feae5742.js";
 import * as monaco from "monaco-editor";
 import { setDiagnosticsOptions } from "monaco-yaml";
 import { useRef, useEffect } from "react";
 import ReactDOM from "react-dom";
+import { Y as YamlEditorStyle } from "./index-44cc930a.js";
 import "dayjs";
 import "i18next";
 import "@refinedev/core";
@@ -15,14 +16,6 @@ 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";

package/dist/PodShell-43c7028e.cjs

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const common = require("./common-1eb43414.cjs");
+const eagle = require("@cloudtower/eagle");
+const React = require("react");
+const index = require("./index-31874f77.cjs");
+const buffer = require("buffer");
+require("@xterm/addon-canvas");
+require("@xterm/addon-fit");
+require("@xterm/addon-search");
+require("@xterm/addon-web-links");
+require("@xterm/addon-webgl");
+require("@xterm/xterm");
+require("copy-to-clipboard");
+require("lodash-es");
+require("@cloudtower/icons-react");
+function addParam(url, key, val) {
+  let out = url + (url.includes("?") ? "&" : "?");
+  if (!Array.isArray(val)) {
+    val = [val];
+  }
+  out += val.map((v) => {
+    if (v === null) {
+      return `${encodeURIComponent(key)}`;
+    } else {
+      return `${encodeURIComponent(key)}=${encodeURIComponent(v)}`;
+    }
+  }).join("&");
+  return out;
+}
+function addParams(url, params) {
+  if (params && typeof params === "object") {
+    Object.keys(params).forEach((key) => {
+      url = addParam(url, key, params[key]);
+    });
+  }
+  return url;
+}
+function base64Encode(str, alphabet = "normal") {
+  let buf;
+  if (str === null || typeof str === "undefined") {
+    return str;
+  }
+  if (typeof buffer.Buffer.from === "function" && buffer.Buffer.from !== Uint8Array.from) {
+    buf = buffer.Buffer.from(str);
+  } else {
+    buf = new buffer.Buffer(str);
+  }
+  if (alphabet === "url") {
+    const m = {
+      "+": "-",
+      "/": "_"
+    };
+    return buf.toString("base64").replace(/[+/]|=+$/g, (char) => m[char] || "");
+  }
+  return buf.toString("base64");
+}
+function base64DecodeToBuffer(str) {
+  if (str === null || typeof str === "undefined") {
+    return str;
+  }
+  if (typeof buffer.Buffer.from === "function" && buffer.Buffer.from !== Uint8Array.from) {
+    return buffer.Buffer.from(str, "base64");
+  } else {
+    return new buffer.Buffer(str, "base64");
+  }
+}
+function base64Decode(str) {
+  return !str ? str : base64DecodeToBuffer(str.replace(/[-_]/g, (char) => char === "-" ? "+" : "/")).toString();
+}
+var OS = /* @__PURE__ */ ((OS2) => {
+  OS2["Linux"] = "linux";
+  OS2["Windows"] = "windows";
+  return OS2;
+})(OS || {});
+const BACKUP_SHELLS = [
+  "windows",
+  "linux"
+  /* Linux */
+];
+const COMMANDS = {
+  [
+    "linux"
+    /* Linux */
+  ]: [
+    "/bin/sh",
+    "-c",
+    'TERM=xterm-256color; export TERM; [ -x /bin/bash ] && ([ -x /usr/bin/script ] && /usr/bin/script -q -c "/bin/bash" /dev/null || exec /bin/bash) || exec /bin/sh'
+  ],
+  [
+    "windows"
+    /* Windows */
+  ]: ["cmd"]
+};
+const PodShell = React.forwardRef(
+  function PodShell2(props, ref) {
+    const { pod, basePath, onSocketStatusChange } = props;
+    const id = pod.id;
+    const [namespace, name] = React.useMemo(() => id.split("/"), [id]);
+    const shellRef = React.useRef(null);
+    const errorMsgRef = React.useRef("");
+    const [osIndex, setOsIndex] = React.useState(0);
+    const [container, setContainer] = React.useState("");
+    const containers = React.useMemo(() => {
+      var _a, _b;
+      return (((_a = pod == null ? void 0 : pod._rawYaml.status) == null ? void 0 : _a.containerStatuses) || []).concat(((_b = pod == null ? void 0 : pod._rawYaml.status) == null ? void 0 : _b.initContainerStatuses) || []).map((containerStatus) => containerStatus.name);
+    }, [pod]);
+    const url = React.useMemo(() => {
+      const os = BACKUP_SHELLS[osIndex];
+      const protocol = location.protocol.includes("https") ? "wss" : "ws";
+      const url2 = container && os ? addParams(
+        `${protocol}://${location.host}${basePath}/api/v1/namespaces/${namespace}/pods/${name}/exec`,
+        {
+          container,
+          stdout: "true",
+          stdin: "true",
+          stderr: "true",
+          tty: "true",
+          command: COMMANDS[
+            os || "linux"
+            /* Linux */
+          ]
+        }
+      ) : "";
+      return url2;
+    }, [container, name, namespace, osIndex, basePath]);
+    const onSocketClose = React.useCallback(
+      (socket, term) => {
+        var _a, _b;
+        if (errorMsgRef.current) {
+          if (osIndex + 1 < BACKUP_SHELLS.length) {
+            setOsIndex(osIndex + 1);
+          } else {
+            term == null ? void 0 : term.writeln(`\x1B[38;2;255;82;82m${errorMsgRef.current}`);
+            (_a = shellRef.current) == null ? void 0 : _a.setSocketStatus(common.SocketStatus.Disconnected);
+            errorMsgRef.current = "";
+          }
+        } else {
+          (_b = shellRef.current) == null ? void 0 : _b.setSocketStatus(common.SocketStatus.Disconnected);
+        }
+      },
+      [osIndex]
+    );
+    const onSocketMessage = React.useCallback(
+      (e, socket, term) => {
+        const type = e.data.substr(0, 1);
+        const msg = base64Decode(e.data.substr(1));
+        if (`${type}` === "1") {
+          term == null ? void 0 : term.write(msg);
+        } else {
+          if (`${type}` === "3") {
+            errorMsgRef.current = msg;
+          }
+        }
+      },
+      []
+    );
+    const fit = React.useCallback(({ rows, cols }) => {
+      var _a;
+      const message = `${"4"}${base64Encode(
+        JSON.stringify({
+          Width: Math.floor(cols),
+          Height: Math.floor(rows)
+        })
+      )}`;
+      (_a = shellRef.current) == null ? void 0 : _a.send(message);
+    }, []);
+    const encode = React.useCallback((input) => `${"0"}${base64Encode(input)}`, []);
+    React.useEffect(() => {
+      if (!container && containers.length) {
+        setContainer(containers[0]);
+      }
+    }, [containers, container]);
+    React.useImperativeHandle(
+      ref,
+      () => ({
+        getAllTerminalContents: () => {
+          var _a;
+          return ((_a = shellRef.current) == null ? void 0 : _a.getAllTerminalContents()) || [];
+        }
+      }),
+      []
+    );
+    return /* @__PURE__ */ common.jsxRuntimeExports.jsx(
+      index.Shell,
+      {
+        ref: shellRef,
+        url,
+        protocols: "base64.channel.k8s.io",
+        encode,
+        fit,
+        toolbarLeftSlot: /* @__PURE__ */ common.jsxRuntimeExports.jsx(
+          eagle.Select,
+          {
+            input: {
+              value: container,
+              onChange(value) {
+                setContainer(value);
+              }
+            },
+            style: {
+              width: "256px"
+            },
+            size: "small",
+            children: containers.map((containerName) => /* @__PURE__ */ common.jsxRuntimeExports.jsx(eagle.AntdOption, { value: containerName, label: containerName, children: containerName }, containerName))
+          }
+        ),
+        onSocketMessage,
+        onSocketClose,
+        onSocketStatusChange
+      }
+    );
+  }
+);
+exports.OS = OS;
+exports.PodShell = PodShell;