@omniviewdev/runtime 0.0.0-nightly.20260225

package/dist/index.js

@@ -0,0 +1,2593 @@
+var zt = Object.defineProperty;
+var Wt = (e, t, n) => t in e ? zt(e, t, { enumerable: !0, configurable: !0, writable: !0, value: n }) : e[t] = n;
+var M = (e, t, n) => Wt(e, typeof t != "symbol" ? t + "" : t, n);
+import { jsx as F, jsxs as ae } from "react/jsx-runtime";
+import _, { useContext as te, createContext as me, useState as q, useRef as de, useEffect as j, useCallback as V, useMemo as Ht } from "react";
+import { Link as Bt, useNavigate as Yt, useLocation as Jt, createMemoryRouter as Vt, RouterProvider as Xt } from "react-router-dom";
+import { P as Zt, G as en, V as tn, S as nn, h as lt, U as rn, R as sn, i as on, j as dt, k as an, L as cn, l as un, m as Ye, n as ln, o as dn, q as fn, r as pn, s as yn, Q as hn, t as mn, u as Je, v as gn, w as ft, F as _n, x as wn, y as pt, D as yt, z as Sn, A as Cn, B as En, E as ht, H as bn, I as vn, J as mt, K as Pn, M as Dn, N as Fn, O as xn, T as In } from "./Client-DGdSmmVk.js";
+import { config as On, exec as An, logs as Ve, networker as Xe, types as T } from "./models.js";
+import { useQueryClient as G, useMutation as v, useQuery as D, keepPreviousData as gt, useQueries as Tn } from "@tanstack/react-query";
+import { useNotificationStack as Nn } from "@omniviewdev/ui/feedback";
+import { EventsOn as A, BrowserOpenURL as _t, EventsOff as be } from "./runtime.js";
+const $e = _.createContext(void 0), xe = {
+  // Plugin
+  PLUGIN_NOT_FOUND: "omniview:plugin/not-found",
+  PLUGIN_NOT_LOADED: "omniview:plugin/not-loaded",
+  PLUGIN_ALREADY_LOADED: "omniview:plugin/already-loaded",
+  PLUGIN_INSTALL_FAILED: "omniview:plugin/install-failed",
+  PLUGIN_LOAD_FAILED: "omniview:plugin/load-failed",
+  PLUGIN_BUILD_FAILED: "omniview:plugin/build-failed",
+  // Settings
+  SETTINGS_MISSING_CONFIG: "omniview:settings/missing-config",
+  SETTINGS_INVALID_CONFIG: "omniview:settings/invalid-config",
+  // Resource
+  RESOURCE_NOT_FOUND: "omniview:resource/not-found",
+  RESOURCE_FORBIDDEN: "omniview:resource/forbidden",
+  RESOURCE_UNAUTHORIZED: "omniview:resource/unauthorized",
+  RESOURCE_CONFLICT: "omniview:resource/conflict",
+  RESOURCE_TIMEOUT: "omniview:resource/timeout",
+  // Connection
+  CONNECTION_NOT_FOUND: "omniview:connection/not-found",
+  CONNECTION_FAILED: "omniview:connection/failed",
+  // Session
+  SESSION_NOT_FOUND: "omniview:session/not-found",
+  SESSION_FAILED: "omniview:session/failed",
+  // General
+  CANCELLED: "omniview:cancelled",
+  INTERNAL: "omniview:internal",
+  VALIDATION: "omniview:validation",
+  NOT_IMPLEMENTED: "omniview:not-implemented"
+};
+function K(e) {
+  if (e == null)
+    return {
+      type: xe.INTERNAL,
+      title: "Unknown error",
+      status: 500,
+      detail: "An unknown error occurred."
+    };
+  let t;
+  if (typeof e == "string" ? t = e : e instanceof Error ? t = e.message : t = String(e), t.startsWith("{"))
+    try {
+      const n = JSON.parse(t);
+      if (typeof n.type == "string" && typeof n.title == "string" && typeof n.status == "number" && typeof n.detail == "string")
+        return n;
+    } catch {
+    }
+  return {
+    type: xe.INTERNAL,
+    title: "Error",
+    status: 500,
+    detail: t
+  };
+}
+function wt(e) {
+  return e == null ? !1 : (typeof e == "string" ? e : e instanceof Error ? e.message : String(e)) === "cancelled" ? !0 : K(e).type === xe.CANCELLED;
+}
+function kn(e) {
+  switch (e.type) {
+    case "navigate":
+      return {
+        label: e.label,
+        onClick: () => {
+          window.location.hash = e.target ?? "";
+        }
+      };
+    case "open-url":
+      return {
+        label: e.label,
+        onClick: () => {
+          window.open(e.target, "_blank");
+        }
+      };
+    case "copy":
+      return {
+        label: e.label,
+        onClick: () => {
+          navigator.clipboard.writeText(e.target ?? "");
+        }
+      };
+    case "retry":
+      return {
+        label: e.label,
+        onClick: () => {
+        }
+      };
+    default:
+      return {
+        label: e.label,
+        onClick: () => {
+        }
+      };
+  }
+}
+function St(e, t) {
+  var s, i;
+  const n = [
+    e.detail,
+    ...((s = e.suggestions) == null ? void 0 : s.map((o) => `• ${o}`)) ?? []
+  ].join(`
+`);
+  return {
+    message: t || (e.title !== "Error" ? e.title : "Operation failed"),
+    status: "error",
+    details: n,
+    actions: (i = e.actions) == null ? void 0 : i.map(kn)
+  };
+}
+function X(e, t, n) {
+  if (wt(t)) return;
+  const r = K(t);
+  e(St(r, n));
+}
+function I(e, t) {
+  return (n) => {
+    if (wt(n)) return;
+    const r = K(n);
+    e(St(r, r.title !== "Error" ? r.title : t));
+  };
+}
+function gs(e) {
+  const { children: t, pluginId: n } = e, [r, s] = _.useState({}), [i, o] = _.useState(new On.PluginMeta()), [a, c] = _.useState(!1), [l, u] = _.useState(null);
+  console.debug("[PluginContextProvider] render", { pluginId: n, metaLoaded: a, metaError: !!l });
+  const y = () => {
+    n === void 0 || n === "" || (console.debug(`[PluginContextProvider] fetching settings for "${n}"`), Zt(n).then((f) => {
+      console.debug(`[PluginContextProvider] settings loaded for "${n}"`, Object.keys(f)), s(f);
+    }).catch((f) => {
+      const m = K(f);
+      console.error(`[PluginContextProvider] error fetching settings for "${n}":`, m.detail);
+    }));
+  }, h = () => {
+    if (n === void 0 || n === "") {
+      console.debug("[PluginContextProvider] skipping meta fetch — empty pluginId");
+      return;
+    }
+    console.debug(`[PluginContextProvider] fetching meta for "${n}"`), u(null), en(n).then((f) => {
+      console.debug(`[PluginContextProvider] meta loaded for "${n}"`, { name: f == null ? void 0 : f.name, version: f == null ? void 0 : f.version }), o(f), c(!0);
+    }).catch((f) => {
+      const m = K(f);
+      console.error(`[PluginContextProvider] error fetching meta for "${n}":`, m.detail), u(m.detail), c(!1);
+    });
+  };
+  return _.useEffect(() => {
+    console.debug(`[PluginContextProvider] useEffect — pluginId changed to "${n}"`), y(), h();
+  }, [n]), l ? /* @__PURE__ */ F("div", { style: {
+    display: "flex",
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center",
+    padding: 24
+  }, children: /* @__PURE__ */ ae("div", { style: {
+    maxWidth: 480,
+    width: "100%",
+    border: "1px solid #7F1D1D",
+    borderRadius: 8,
+    backgroundColor: "#1C1917",
+    padding: 20,
+    fontFamily: '-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif'
+  }, children: [
+    /* @__PURE__ */ ae("div", { style: { display: "flex", alignItems: "center", gap: 8, marginBottom: 12 }, children: [
+      /* @__PURE__ */ ae("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", stroke: "#EF4444", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+        /* @__PURE__ */ F("circle", { cx: "12", cy: "12", r: "10" }),
+        /* @__PURE__ */ F("line", { x1: "12", y1: "8", x2: "12", y2: "12" }),
+        /* @__PURE__ */ F("line", { x1: "12", y1: "16", x2: "12.01", y2: "16" })
+      ] }),
+      /* @__PURE__ */ F("span", { style: { fontSize: 14, fontWeight: 600, color: "#FECACA" }, children: "Plugin failed to load" })
+    ] }),
+    /* @__PURE__ */ F("p", { style: { fontSize: 13, color: "#A1A1AA", margin: "0 0 16px" }, children: l }),
+    /* @__PURE__ */ F(
+      "button",
+      {
+        onClick: () => h(),
+        style: {
+          background: "transparent",
+          color: "#F87171",
+          border: "1px solid #7F1D1D",
+          borderRadius: 6,
+          padding: "6px 14px",
+          fontSize: 13,
+          fontWeight: 500,
+          cursor: "pointer"
+        },
+        children: "Retry"
+      }
+    )
+  ] }) }) : a ? /* @__PURE__ */ F($e.Provider, { value: { pluginId: n, settings: r, meta: i }, children: t }) : /* @__PURE__ */ ae("div", { style: {
+    display: "flex",
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center"
+  }, children: [
+    /* @__PURE__ */ F("div", { style: {
+      width: 24,
+      height: 24,
+      border: "2px solid #3F3F46",
+      borderTopColor: "#A1A1AA",
+      borderRadius: "50%",
+      animation: "plugin-spin 0.8s linear infinite"
+    } }),
+    /* @__PURE__ */ F("style", { children: "@keyframes plugin-spin { to { transform: rotate(360deg); } }" })
+  ] });
+}
+function Le() {
+  const e = te($e);
+  if (!e)
+    throw new Error("usePluginContext must be used within a PluginContextProvider");
+  return e;
+}
+function _s() {
+  return Le().settings;
+}
+const Ct = me(void 0), ws = ({ children: e }) => {
+  const [t, n] = q({}), r = () => {
+    tn().then((i) => {
+      console.log("Fetched settings:", i), n(i);
+    }).catch((i) => {
+      console.error("Error fetching settings:", i);
+    });
+  };
+  _.useEffect(() => {
+    r();
+  }, []);
+  const s = () => {
+    r();
+  };
+  return /* @__PURE__ */ F(Ct.Provider, { value: { settings: t, reload: s }, children: e });
+}, Rn = {
+  height: 32,
+  focused: 0,
+  tabs: [],
+  createTab: () => {
+  },
+  createTabs: () => {
+  },
+  updateTab: () => {
+  },
+  focusTab: () => {
+  },
+  reorderTab: () => {
+  },
+  closeTab: () => {
+  },
+  closeTabs: () => {
+  },
+  resizeDrawer: () => {
+  },
+  closeDrawer: () => {
+  },
+  fullscreenDrawer: () => {
+  }
+}, Mn = _.createContext(Rn), $n = me(void 0), Ln = _.createContext(void 0), Et = _.createContext(void 0), qn = 3e4, Ss = ({ children: e }) => {
+  const [t, n] = _.useState([]), r = _.useCallback((a) => {
+    n((c) => [a, ...c]);
+  }, []), s = _.useCallback((a, c) => {
+    n(
+      (l) => l.map((u) => u.id === a ? { ...u, ...c } : u)
+    );
+  }, []), i = _.useCallback((a) => {
+    n((c) => c.filter((l) => l.id !== a));
+  }, []);
+  _.useEffect(() => {
+    const a = [];
+    for (const c of t)
+      if (c.status === "completed" || c.status === "error") {
+        const l = Date.now() - (c.completedAt ?? c.startedAt), u = Math.max(0, qn - l);
+        a.push(setTimeout(() => i(c.id), u));
+      }
+    return () => a.forEach(clearTimeout);
+  }, [t, i]);
+  const o = _.useMemo(
+    () => ({ operations: t, addOperation: r, updateOperation: s, removeOperation: i }),
+    [t, r, s, i]
+  );
+  return /* @__PURE__ */ F(Et.Provider, { value: o, children: e });
+};
+var Ie = function(e, t) {
+  return Ie = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(n, r) {
+    n.__proto__ = r;
+  } || function(n, r) {
+    for (var s in r) Object.prototype.hasOwnProperty.call(r, s) && (n[s] = r[s]);
+  }, Ie(e, t);
+};
+function Gn(e, t) {
+  if (typeof t != "function" && t !== null)
+    throw new TypeError("Class extends value " + String(t) + " is not a constructor or null");
+  Ie(e, t);
+  function n() {
+    this.constructor = e;
+  }
+  e.prototype = t === null ? Object.create(t) : (n.prototype = t.prototype, new n());
+}
+var ve = "Invariant Violation", Ze = Object.setPrototypeOf, Kn = Ze === void 0 ? function(e, t) {
+  return e.__proto__ = t, e;
+} : Ze, Un = (
+  /** @class */
+  function(e) {
+    Gn(t, e);
+    function t(n) {
+      n === void 0 && (n = ve);
+      var r = e.call(this, typeof n == "number" ? ve + ": " + n + " (see https://github.com/apollographql/invariant-packages)" : n) || this;
+      return r.framesToPop = 1, r.name = ve, Kn(r, t.prototype), r;
+    }
+    return t;
+  }(Error)
+);
+function Oe(e, t) {
+  if (!e)
+    throw new Un(t);
+}
+var bt = ["debug", "log", "warn", "error", "silent"], jn = bt.indexOf("log");
+function ce(e) {
+  return function() {
+    if (bt.indexOf(e) >= jn) {
+      var t = console[e] || console.log;
+      return t.apply(console, arguments);
+    }
+  };
+}
+(function(e) {
+  e.debug = ce("debug"), e.log = ce("log"), e.warn = ce("warn"), e.error = ce("error");
+})(Oe || (Oe = {}));
+const vt = me(void 0), Pt = () => te(vt), Cs = (e) => {
+  const t = Pt();
+  return t == null ? void 0 : t.getExtensionPoint(e);
+}, Es = (e) => {
+  const t = Pt(), n = t == null ? void 0 : t.getExtensionPoint(e);
+  return n ? n.provide({ getCacheKey: () => e }) : [];
+}, bs = ({ registry: e, children: t }) => {
+  const n = _.useRef(e);
+  return _.useEffect(() => {
+    Oe(
+      n.current === e,
+      "You can't change the extension registry after it has been rendered"
+    );
+  }, [e]), /* @__PURE__ */ F(vt.Provider, { value: n.current, children: _.Children.only(t) });
+}, et = (e) => {
+  if (!e || typeof e != "string")
+    throw new TypeError(`extensionName is required to be a string and can't be: "${e}" (${typeof e})`);
+  return e.trim();
+};
+class Qn {
+  constructor(t) {
+    M(this, "_settings");
+    M(this, "_extensions", /* @__PURE__ */ new Map());
+    M(this, "_lookupCache", /* @__PURE__ */ new Map());
+    M(this, "_matchCache", /* @__PURE__ */ new Map());
+    M(this, "_matcher");
+    const { matcher: n, ...r } = t;
+    this._settings = r, this._matcher = t.matcher;
+  }
+  settings() {
+    return this._settings;
+  }
+  /**
+  * Registers a new component within the registry. Throws an error if a component with the same ID already exists.
+  * This method should be used when initializing components or dynamically adding new components at runtime.
+  *
+  * @param opts The registration options for the component, containing its ID, plugin, and other metadata.
+  * @throws Error if a component with the same ID is already registered.
+  * @example
+  * registry.register({
+  *   id: 'unique-sidebar-item',
+  *   plugin: 'examplePlugin',
+  *   label: 'My Sidebar Item',
+  *   component: MyComponent,
+  * });
+  */
+  register(t) {
+    if (this._extensions.get(t.id))
+      throw new Error(`Resource sidebar view with id ${t.id} already exists`);
+    const n = {
+      ...t,
+      registeredAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      enabled: !0
+    };
+    this._extensions.set(t.id, n);
+    const r = Array.from(this._matchCache.keys());
+    for (const s of r)
+      s.startsWith(t.plugin) && this._matchCache.delete(s);
+  }
+  /**
+  * Unregisters a component from the registry by its ID. Useful for cleanup or when components are dynamically removed.
+  *
+  * @param id The ID of the component to unregister.
+  * @example
+  * registry.unregister('unique-sidebar-item');
+  */
+  unregister(t) {
+    this._extensions.delete(t);
+  }
+  /**
+  * Retrieves a component by its ID from the registry. Returns undefined if no such component exists.
+  *
+  * @param id The ID of the component to retrieve.
+  * @returns The component associated with the given ID, or undefined if not found.
+  * @example
+  * const component = registry.get('unique-sidebar-item');
+  * if (component) {
+  *   render(component);
+  * }
+  */
+  get(t) {
+    var n;
+    return (n = this._extensions.get(t)) == null ? void 0 : n.component;
+  }
+  /**
+  * Lists all registered components in the registry. Useful for debugging or generating summaries of available components.
+  *
+  * @returns An array of all registered components.
+  * @example
+  * const allComponents = registry.list();
+  * console.log('Registered Components:', allComponents);
+  */
+  list() {
+    return Array.from(this._extensions.values());
+  }
+  generateMatchCacheKey(t) {
+    return `${t.plugin}/${t.id}`;
+  }
+  /**
+   * Calculate the matches for the given context.
+   */
+  calculateMatches(t) {
+    if (!this._matcher)
+      return Array.from(this._extensions.values());
+    const n = [];
+    for (const r of this._extensions.values()) {
+      const s = this.generateMatchCacheKey(r), i = this._matchCache.has(s);
+      if (i && this._matchCache.get(s)) {
+        n.push(r);
+        continue;
+      }
+      this._matcher(t, r) ? (this._matchCache.set(s, !0), n.push(r)) : i || this._matchCache.set(s, !1);
+    }
+    return n;
+  }
+  /**
+   * Preload the registry caches with the given expected context to avoid on-first-request calculation.
+   * This is useful when the registry is used to provide components for a specific context, like for
+   * specific resources types.
+   *
+   * If the cache is already populated for the expected context, the cache key will be recalculated.
+   *
+   * @param context The context expected to be called preload the registry with on provide.
+   */
+  preload(t) {
+    const n = this.calculateMatches(t), r = t.getCacheKey();
+    this._lookupCache.set(r, n.map((s) => s.id));
+  }
+  /**
+   * Provide the components that match the given context.
+   */
+  provide(t) {
+    if (this._settings.disabled)
+      return [];
+    if (this._settings.mode === "single") {
+      const i = this._extensions.get(this._settings.selected);
+      return i ? [i.component] : [];
+    }
+    const n = t.getCacheKey();
+    let r = this._lookupCache.get(n);
+    if (r) {
+      let i = r.map((o) => this._extensions.get(o)).filter((o) => !!o).map((o) => o.component);
+      return this._settings.order && (i = this.reorderComponents(i, r, this._settings.order)), i;
+    }
+    r = this.calculateMatches(t).map((i) => i.id), this._lookupCache.set(n, r);
+    let s = r.map((i) => this._extensions.get(i)).filter((i) => !!i).map((i) => i.component);
+    return this._settings.order && (s = this.reorderComponents(s, r, this._settings.order)), s;
+  }
+  reorderComponents(t, n, r) {
+    const s = new Map(n.map((i, o) => [i, t[o]]));
+    return r.map((i) => s.get(i)).filter((i) => !!i);
+  }
+  /**
+   * Reorder the components in the registry based on the given order.
+   */
+  reorder(t) {
+    const n = t.map((o) => this._extensions.get(o)).filter((o) => !!o), r = Array.from(this._extensions.values()).filter((o) => !t.includes(o.id)), s = [...n, ...r];
+    this._extensions.clear(), s.forEach((o) => this._extensions.set(o.id, o));
+    const i = Array.from(this._lookupCache.keys());
+    for (const o of i) {
+      const a = this._lookupCache.get(o);
+      if (!a)
+        continue;
+      const c = a.filter((l) => t.includes(l));
+      this._lookupCache.set(o, c);
+    }
+  }
+  clearLookupCache() {
+    this._lookupCache.clear();
+  }
+  clearMatchCache() {
+    this._matchCache.clear();
+  }
+  clearAllCaches() {
+    this.clearLookupCache(), this.clearMatchCache();
+  }
+}
+class vs {
+  constructor({ initialStores: t }) {
+    M(this, "store", {});
+    t.forEach((n) => {
+      this.addExtensionPoint(n);
+    });
+  }
+  /**
+   * Add a new extension point to the registry. If the extension point already exists, it will not be
+   * added again.
+   * @param opts The settings for the extension point
+   */
+  addExtensionPoint(t) {
+    let n = et(t.id);
+    if (console.log("validated", n), console.log("store", this.store), this.store[n]) {
+      console.warn(`Extension point ${n} already exists. Not adding again.`);
+      return;
+    }
+    this.store[n] = new Qn(t);
+  }
+  /**
+   * Get an extension point from the registry.
+   */
+  getExtensionPoint(t) {
+    return t = et(t), this.store[t];
+  }
+  /**
+   * List all extension points in the registry.
+   */
+  listExtensionPointIds() {
+    return Object.keys(this.store);
+  }
+  // /**
+  //  * List extension points, grouped by owner
+  //  */
+  // listExtensionPointsByOwner(): Record<string, ExtensionPointSettings[]> {
+  //   const byOwner: Record<string, ExtensionPointSettings[]> = {};
+  //   Object.values(this.store).forEach((store) => {
+  //     const owner = store.settings().owner;
+  //     if (!byOwner[owner]) {
+  //       byOwner[owner] = [];
+  //     }
+  //
+  //     byOwner[owner].push(store.settings());
+  //   });
+  //   return byOwner;
+  // }
+  /**
+   * List all extensions in the registry.
+   */
+  listExtensionPoints() {
+    return Object.values(this.store).map((t) => t.settings());
+  }
+}
+const Dt = me(void 0), zn = {
+  default: "info",
+  info: "info",
+  success: "success",
+  warning: "warning",
+  error: "error"
+}, Ps = ({ children: e }) => {
+  const { push: t } = Nn(), [n, r] = _.useState([]), s = (o) => {
+    r((a) => [...a, o]);
+  }, i = (o, a, c) => {
+    const l = typeof o == "object";
+    let u = "", y = "info", h, f = 5e3, m;
+    if (l) {
+      if (u = o.message, o.showOnce) {
+        if (n.includes(u))
+          return;
+        s(u);
+      }
+      y = o.status, h = o.details, f = o.autoHideDuration ?? 5e3, m = o.actions;
+    } else
+      u = o, y = a, h = c;
+    t({
+      severity: zn[y] ?? "info",
+      title: u,
+      message: h,
+      timeout: f,
+      actions: m
+    });
+  };
+  return /* @__PURE__ */ F(Dt.Provider, { value: { showSnackbar: i }, children: e });
+}, $ = () => {
+  const e = te(Dt);
+  if (e === void 0)
+    throw new Error("useCustomSnackbar must be used within a CustomSnackbarProvider");
+  return e;
+};
+function P(e) {
+  const t = te($e), n = (t == null ? void 0 : t.pluginId) ?? e;
+  if (!n)
+    throw new Error(
+      "pluginID must be provided either via PluginContext or as an explicit parameter"
+    );
+  return n;
+}
+const Ds = ({ pluginID: e, connectionID: t }) => {
+  const n = P(e), r = G(), { showSnackbar: s } = $(), i = [n, "connection", "detail", t], { mutateAsync: o } = v({
+    mutationFn: async () => nn(n, t),
+    onSuccess(y) {
+      r.setQueryData(i, y), r.invalidateQueries({
+        queryKey: ["EDITOR_SCHEMAS", n, t]
+      });
+    },
+    onError: I(s, "Failed to start connection")
+  }), { mutateAsync: a } = v({
+    mutationFn: async () => lt(n, t),
+    onSuccess(y) {
+      r.setQueryData(i, y);
+    },
+    onError: I(s, "Failed to stop connection")
+  }), { mutateAsync: c } = v({
+    mutationFn: async (y) => rn(n, y),
+    onSuccess(y, { name: h }) {
+      s({ message: `Connection ${h} successfully updated`, status: "success" }), r.setQueryData(i, u), r.setQueriesData(
+        { queryKey: [n, "connection", "list"] },
+        (f) => f == null ? void 0 : f.map((m) => m.id === t ? y : m)
+      );
+    },
+    onError: I(s, "Failed to update connection")
+  }), { mutateAsync: l } = v({
+    mutationFn: async () => sn(n, t),
+    onSuccess() {
+      s({ message: "Connection successfully removed", status: "success" }), r.setQueryData(i, void 0), r.setQueriesData(
+        { queryKey: [n, "connection", "list"] },
+        (y) => y == null ? void 0 : y.filter((h) => h.id !== t)
+      );
+    },
+    onError: I(s, "Failed to remove connection")
+  }), u = D({
+    queryKey: i,
+    queryFn: async () => on(n, t)
+  });
+  return {
+    /**
+     * Get the connection
+     */
+    connection: u,
+    /**
+     * Start the connection
+     */
+    startConnection: o,
+    /**
+     * Stop the connection
+     */
+    stopConnection: a,
+    /**
+     * Update the connection.
+     */
+    updateConnection: c,
+    /**
+     * Delete the connection
+     */
+    deleteConnection: l
+  };
+}, Wn = (e) => [e, "connection", "list"], Fs = ({ plugin: e }) => {
+  const t = P(e), n = G(), { showSnackbar: r } = $(), s = Wn(t), { mutateAsync: i } = v({
+    mutationFn: async (l) => dt(t, l.id),
+    onError: I(r, "Failed to start connection informer")
+  }), { mutateAsync: o } = v({
+    mutationFn: async (l) => an(t, l.id),
+    onError: I(r, "Failed to stop connection informer")
+  }), a = _.useCallback((l) => {
+    console.log("got update to connections", l), n.setQueryData(s, l);
+  }, []);
+  return _.useEffect(() => {
+    const l = A(`${t}/connection/sync`, a);
+    return () => {
+      l();
+    };
+  }, []), {
+    connections: D({
+      queryKey: s,
+      queryFn: async () => {
+        try {
+          return await cn(t);
+        } catch (l) {
+          console.log(l), I(r, "Failed to load connections")(l);
+        }
+        return [];
+      },
+      staleTime: 3e4,
+      placeholderData: gt
+    }),
+    startInformer: i,
+    stopInformer: o
+  };
+}, xs = ({ pluginID: e, connectionID: t }) => {
+  const n = P(e);
+  return {
+    /**
+     * Get the connection
+     */
+    namespaces: D({
+      queryKey: [n, "connection", "namespaces", t],
+      queryFn: async () => un(n, t)
+    })
+  };
+};
+var Hn = /* @__PURE__ */ ((e) => (e[e.OnConnect = 0] = "OnConnect", e[e.OnFirstQuery = 1] = "OnFirstQuery", e[e.Never = 2] = "Never", e))(Hn || {}), x = /* @__PURE__ */ ((e) => (e[e.Pending = 0] = "Pending", e[e.Syncing = 1] = "Syncing", e[e.Synced = 2] = "Synced", e[e.Error = 3] = "Error", e[e.Cancelled = 4] = "Cancelled", e))(x || {});
+function Ft(e) {
+  const t = Object.values(e.states), n = t.length;
+  let r = 0, s = 0;
+  for (const a of t)
+    a === x.Synced && r++, a === x.Error && s++;
+  const i = t.filter(
+    (a) => a === x.Synced || a === x.Error || a === x.Cancelled
+  ).length, o = n > 0 ? i / n : 0;
+  return {
+    pluginID: e.pluginID,
+    connectionID: e.connectionID,
+    totalResources: n,
+    syncedCount: r,
+    errorCount: s,
+    doneCount: i,
+    progress: o
+  };
+}
+function fe(e) {
+  return e.totalResources > 0 && e.doneCount >= e.totalResources;
+}
+function xt(e) {
+  return e.some((t) => !fe(t));
+}
+function It(e) {
+  const t = e.reduce((r, s) => r + s.totalResources, 0);
+  return t === 0 ? 0 : e.reduce((r, s) => r + s.doneCount, 0) / t;
+}
+function qe(e) {
+  return `${e.pluginId}/${e.connection}`;
+}
+function Ot(e, t) {
+  const n = qe(t);
+  e.has(n) || e.set(n, {
+    states: {},
+    pluginID: t.pluginId,
+    connectionID: t.connection
+  });
+  const r = e.get(n);
+  return r.states[t.resourceKey] = t.state, r;
+}
+function Is() {
+  const [e, t] = q(/* @__PURE__ */ new Set()), [n, r] = q({}), [s, i] = q(/* @__PURE__ */ new Map()), o = de(/* @__PURE__ */ new Map());
+  j(() => {
+    Ye().then((p) => {
+      p && r(p);
+    }).catch(() => {
+    });
+  }, []), j(() => A("connection/status", (S) => {
+    const w = `${S.pluginID}/${S.connectionID}`;
+    S.status === "DISCONNECTED" ? (t((b) => {
+      const d = new Set(b);
+      return d.delete(w), d;
+    }), i((b) => {
+      const d = new Map(b);
+      return d.delete(w), d;
+    }), o.current.delete(w)) : t((b) => {
+      const d = new Set(b);
+      return d.add(w), d;
+    }), Ye().then((b) => {
+      b && r(b);
+    }).catch(() => {
+    });
+  }), []);
+  const a = V((p) => {
+    const S = qe(p);
+    t((d) => {
+      if (d.has(S)) return d;
+      const g = new Set(d);
+      return g.add(S), g;
+    });
+    const w = Ot(o.current, p), b = Ft(w);
+    i((d) => {
+      const g = new Map(d);
+      return g.set(S, b), g;
+    });
+  }, []);
+  j(() => A("informer/STATE", a), [a]);
+  const c = V(async (p, S) => {
+    await lt(p, S);
+  }, []), l = V(async (p, S) => {
+    await dt(p, S);
+  }, []), u = [];
+  for (const p of e) {
+    const [S, w] = p.split("/", 2), d = (n[S] ?? []).find((R) => R.id === w), g = s.get(p), E = g != null && !fe(g), C = g != null && g.errorCount > 0;
+    u.push({
+      pluginID: S,
+      connectionID: w,
+      name: (d == null ? void 0 : d.name) ?? w,
+      avatar: (d == null ? void 0 : d.avatar) ?? "",
+      isStarted: !0,
+      sync: g,
+      isSyncing: E,
+      hasErrors: C
+    });
+  }
+  const y = /* @__PURE__ */ new Map();
+  for (const p of u) {
+    const S = y.get(p.pluginID) ?? [];
+    S.push(p), y.set(p.pluginID, S);
+  }
+  const h = Array.from(s.values()), f = u.filter((p) => p.isSyncing), m = u.filter((p) => p.hasErrors);
+  return {
+    entries: u,
+    grouped: y,
+    connectedCount: u.length,
+    syncingCount: f.length,
+    errorCount: m.length,
+    hasSyncing: xt(h),
+    aggregateProgress: It(h),
+    disconnect: c,
+    retryInformer: l
+  };
+}
+function Bn(e, t) {
+  return window.go.data.Client.Get(e, t);
+}
+function Yn(e, t, n) {
+  return window.go.data.Client.Set(e, t, n);
+}
+function Os(e, t, n) {
+  const r = P(e), s = G(), i = [r, "data", t], o = D({
+    queryKey: i,
+    queryFn: async () => {
+      const c = await Bn(r, t);
+      return c ?? n;
+    }
+  }), a = v({
+    mutationFn: async (c) => {
+      await Yn(r, t, c);
+    },
+    onMutate: async (c) => {
+      await s.cancelQueries({ queryKey: i });
+      const l = s.getQueryData(i);
+      return s.setQueryData(i, c), { previous: l };
+    },
+    onError: (c, l, u) => {
+      (u == null ? void 0 : u.previous) !== void 0 && s.setQueryData(i, u.previous);
+    },
+    onSettled: () => {
+      s.invalidateQueries({ queryKey: i });
+    }
+  });
+  return {
+    data: o.data ?? n,
+    update: async (c) => {
+      await a.mutateAsync(c);
+    },
+    isLoading: o.isLoading
+  };
+}
+const As = () => {
+  const e = te($n);
+  if (!e) throw new Error("useRightDrawer must be used within a RightDrawerProvider");
+  return e;
+}, At = () => {
+  const e = te(Mn);
+  if (e === void 0)
+    throw new Error("useBottomDrawer must be used within a BottomDrawerProvider");
+  return e;
+}, Ts = ({ pluginID: e }) => {
+  const t = P(e), { showSnackbar: n } = $(), { createTab: r, updateTab: s } = At();
+  return {
+    createSession: v({
+      mutationFn: async ({ connectionID: o, icon: a, label: c, opts: l }) => {
+        const u = `pending-${crypto.randomUUID()}`;
+        r({
+          id: u,
+          title: c ?? "Connecting...",
+          variant: "terminal",
+          icon: a ?? "LuSquareTerminal",
+          properties: {
+            status: "connecting",
+            pluginID: t,
+            connectionID: o,
+            opts: { ...l }
+          }
+        });
+        const y = An.SessionOptions.createFrom({
+          command: ["/bin/bash"],
+          tty: !0,
+          ...l
+        });
+        try {
+          const h = await ln(t, o, y);
+          s(
+            { id: u },
+            {
+              id: h.id,
+              title: c ?? `Session ${h.id.substring(0, 8)}`,
+              properties: { status: "connected", pluginID: t, connectionID: o, opts: { ...l } }
+            }
+          );
+        } catch (h) {
+          const f = K(h);
+          s(
+            { id: u },
+            {
+              properties: { status: "error", error: f.detail, pluginID: t, connectionID: o, opts: { ...l } }
+            }
+          ), X(n, h, "Failed to start session");
+        }
+      }
+    }).mutateAsync
+  };
+}, Ns = ({ pluginID: e }) => {
+  const t = P(e), { showSnackbar: n } = $(), { createTab: r } = At(), s = v({
+    mutationFn: async ({
+      connectionID: o,
+      resourceKey: a,
+      resourceID: c,
+      resourceData: l,
+      icon: u,
+      label: y,
+      target: h,
+      follow: f = !0,
+      tailLines: m = 1e3,
+      params: p
+    }) => {
+      const S = Ve.CreateSessionOptions.createFrom({
+        resource_key: a,
+        resource_id: c,
+        resource_data: l,
+        options: Ve.LogSessionOptions.createFrom({
+          target: h ?? "",
+          follow: f,
+          include_previous: !1,
+          include_timestamps: !0,
+          tail_lines: m,
+          since_seconds: 0,
+          limit_bytes: 0,
+          include_source_events: !0,
+          params: p ?? {}
+        })
+      }), w = await dn(t, o, S);
+      return r({
+        id: w.id,
+        title: y ?? `Logs ${w.id.substring(0, 8)}`,
+        variant: "logs",
+        icon: u ?? "LuLogs"
+      }), w;
+    },
+    onError: I(n, "Failed to start log session")
+  }), i = v({
+    mutationFn: async (o) => {
+      await fn(o);
+    },
+    onError: I(n, "Failed to close log session")
+  });
+  return {
+    createLogSession: s.mutateAsync,
+    closeLogSession: i.mutateAsync
+  };
+}, ks = () => D({
+  queryKey: ["metric", "providers"],
+  queryFn: pn,
+  staleTime: 3e4
+}), Jn = (e) => D({
+  queryKey: ["metric", "providers", e],
+  queryFn: () => yn(e),
+  enabled: !!e,
+  staleTime: 3e4
+}), Rs = (e) => {
+  var S, w;
+  const {
+    connectionID: t,
+    resourceKey: n,
+    resourceID: r,
+    resourceNamespace: s = "",
+    resourceData: i = {},
+    metricIDs: o = [],
+    shape: a = 0,
+    // CURRENT
+    timeRange: c,
+    refreshInterval: l = 0,
+    enabled: u = !0
+  } = e, {
+    data: y,
+    isLoading: h
+  } = Jn(n), f = y ?? [], m = c ? Math.max(
+    Math.floor((c.end.getTime() - c.start.getTime()) / 250),
+    15e3
+  ) * 1e6 : 0, p = D({
+    queryKey: [
+      "metric",
+      "query",
+      t,
+      n,
+      r,
+      s,
+      o,
+      a,
+      (S = c == null ? void 0 : c.start) == null ? void 0 : S.getTime(),
+      (w = c == null ? void 0 : c.end) == null ? void 0 : w.getTime()
+    ],
+    queryFn: () => hn(
+      t,
+      n,
+      r,
+      s,
+      i,
+      o,
+      a,
+      (c == null ? void 0 : c.start) ?? /* @__PURE__ */ new Date(0),
+      (c == null ? void 0 : c.end) ?? /* @__PURE__ */ new Date(0),
+      m
+    ),
+    enabled: u && !!t && !!n && (n.startsWith("cluster::") || !!r) && f.length > 0,
+    refetchInterval: l > 0 ? l : void 0,
+    staleTime: 5e3,
+    // Keep previous data visible while fetching new data (e.g. on time range change)
+    // to prevent the chart from blinking empty.
+    placeholderData: gt
+  });
+  return {
+    data: p.data ?? void 0,
+    providers: f,
+    isLoading: h || p.isLoading,
+    error: p.error,
+    refetch: p.refetch
+  };
+}, Ms = (e) => {
+  const {
+    pluginID: t,
+    connectionID: n,
+    resourceKey: r,
+    resourceID: s,
+    resourceNamespace: i = "",
+    resourceData: o = {},
+    metricIDs: a = [],
+    interval: c = 1e4,
+    enabled: l = !0
+  } = e, u = P(t), [y, h] = q(null), [f, m] = q(null), [p, S] = q(!1), [w, b] = q(null), d = de(null), g = V(async () => {
+    if (!(!l || !u || !n || !r || !s))
+      try {
+        const C = await mn(u, n, {
+          resource_key: r,
+          resource_id: s,
+          resource_namespace: i,
+          resource_data: o,
+          metric_ids: a,
+          interval: c * 1e6
+          // ms to nanoseconds for Go time.Duration
+        });
+        m(C), S(!0), b(null);
+        const R = A(`core/metrics/data/${C}`, (B) => {
+          try {
+            const L = JSON.parse(B);
+            L.results && h(L.results);
+          } catch (L) {
+            console.error("Failed to parse metric stream data:", L);
+          }
+        }), ie = A(`core/metrics/error/${C}`, (B) => {
+          try {
+            const L = JSON.parse(B);
+            b(L.error || "Unknown error");
+          } catch {
+            b("Failed to parse metric stream error");
+          }
+        });
+        d.current = () => {
+          R(), ie();
+        };
+      } catch (C) {
+        b(C instanceof Error ? C.message : String(C));
+      }
+  }, [u, n, r, s, i, a, c, l]), E = V(async () => {
+    if (f)
+      try {
+        await Je(f);
+      } catch (C) {
+        console.error("Failed to unsubscribe:", C);
+      }
+    d.current && (d.current(), d.current = null), m(null), S(!1);
+  }, [f]);
+  return j(() => () => {
+    f && Je(f).catch(console.error), d.current && d.current();
+  }, [f]), {
+    data: y,
+    subscriptionID: f,
+    isStreaming: p,
+    error: w,
+    start: g,
+    stop: E
+  };
+}, J = ["networker", "portforward", "all-sessions"];
+function $s() {
+  const { showSnackbar: e } = $(), t = G(), n = D({
+    queryKey: [...J],
+    queryFn: async () => gn().catch((i) => {
+      if (K(i).detail.includes("not found")) return [];
+      throw i;
+    }),
+    retry: !1
+  });
+  j(() => {
+    const i = A("core/networker/portforward/created", () => {
+      t.invalidateQueries({ queryKey: [...J] });
+    }), o = A("core/networker/portforward/closed", () => {
+      t.invalidateQueries({ queryKey: [...J] });
+    });
+    return () => {
+      i(), o();
+    };
+  }, [t]);
+  const r = n.data ?? [], s = v({
+    mutationFn: async (i) => ft(i),
+    onError: I(e, "Failed to close port forwarding session"),
+    onSuccess: async () => {
+      await t.invalidateQueries({ queryKey: [...J] });
+    }
+  });
+  return {
+    sessions: n,
+    activeSessions: r,
+    closeSession: s.mutateAsync,
+    openInBrowser: (i) => _t(`http://localhost:${i}`)
+  };
+}
+function Ls({ pluginID: e, connectionID: t, resourceID: n }) {
+  const r = P(e), s = ["networker", "portforward", "sessions", r, t, n], { showSnackbar: i } = $(), o = G(), a = D({
+    queryKey: s,
+    queryFn: async () => _n(r, t, Xe.FindPortForwardSessionRequest.createFrom({
+      resource_id: n,
+      connection_id: t
+    })).catch((u) => {
+      const y = K(u);
+      return y.detail.includes("not found") ? [] : (i({ message: "Failed to fetch port forward sessions", status: "error", details: y.detail }), []);
+    }),
+    retry: !1
+  }), c = v({
+    mutationFn: async ({ opts: u }) => {
+      const y = Xe.PortForwardSessionOptions.createFrom({
+        local_port: u.localPort || 0,
+        remote_port: u.remotePort,
+        protocol: u.protocol || "TCP",
+        connection_type: "RESOURCE",
+        connection: {
+          resource_data: u.resource,
+          connection_id: t,
+          plugin_id: r,
+          resource_id: u.resourceId,
+          resource_key: u.resourceKey
+        },
+        labels: u.labels ?? {},
+        params: u.parameters ?? {}
+      }), h = await wn(r, t, y);
+      return u.openInBrowser && _t(`http://localhost:${h.local_port}`), h;
+    },
+    onError: I(i, "Failed to start port forwarding session"),
+    onSuccess: async () => {
+      await Promise.all([
+        o.invalidateQueries({ queryKey: s }),
+        o.invalidateQueries({ queryKey: [...J] })
+      ]);
+    }
+  }), l = v({
+    mutationFn: async ({ opts: u }) => ft(u.sessionID),
+    onError: I(i, "Failed to close port forwarding session"),
+    onSuccess: async () => {
+      await Promise.all([
+        o.invalidateQueries({ queryKey: s }),
+        o.invalidateQueries({ queryKey: [...J] })
+      ]);
+    }
+  });
+  return {
+    sessions: a,
+    forward: c.mutateAsync,
+    close: l.mutateAsync
+  };
+}
+const qs = () => {
+  const e = _.useContext(Ln);
+  if (!e) throw new Error("useConfirmationModal must be used within a ConfirmationModalProvider");
+  return e;
+}, Gs = ({
+  pluginID: e,
+  connectionID: t,
+  resourceKey: n,
+  resourceID: r,
+  namespace: s = "",
+  getParams: i = {},
+  updateParams: o = {},
+  deleteParams: a = {}
+}) => {
+  const c = P(e), l = G(), { showSnackbar: u } = $(), y = ["RESOURCE", c, t, n, r, s], { mutateAsync: h } = v({
+    mutationFn: async (p) => pt(c, t, n, T.UpdateInput.createFrom({
+      params: { ...o, ...p.params },
+      input: { ...o, ...p.input },
+      id: r,
+      namespace: s
+    })),
+    onSuccess: async () => {
+      u(`Resource ${r} updated`, "success"), await l.invalidateQueries({ queryKey: y });
+    },
+    onError: I(u, `Failed to update resource ${r}`)
+  }), { mutateAsync: f } = v({
+    mutationFn: async (p) => yt(c, t, n, T.DeleteInput.createFrom({
+      params: { ...a, ...p.params },
+      input: { ...a, ...p.input },
+      id: r,
+      ...p,
+      namespace: s
+    })),
+    onSuccess: async () => {
+      u(`Resource ${r} deleted`, "success"), await l.invalidateQueries({ queryKey: y });
+    },
+    onError: I(u, `Failed to delete resource ${r}`)
+  });
+  return {
+    /**
+     * Fetch result for the resource. The client will automatically cache the result, and update the cache
+     * when the resource is updated or deleted via the returned update and remove mutation functions.
+     */
+    resource: D({
+      queryKey: y,
+      queryFn: async () => Sn(c, t, n, T.GetInput.createFrom({
+        params: i,
+        id: r,
+        namespace: s
+      })),
+      retry: !1
+    }),
+    /**
+     * Update an existing resource. A set of optional parameters can be passed to customize the update behavior,
+     * which if specified, will add additional default behavior set via the hook options.
+     *
+     * @params opts Optional parameters to pass to the resource update
+     */
+    update: h,
+    /**
+     * Delete an existing resource. A set of optional parameters can be passed to customize the delete behavior,
+     * which if specified, will add additional default behavior set via the hook options.
+     *
+     * @params {object} opts Optional parameters to pass to the resource delete
+     */
+    remove: f
+  };
+}, Ks = (e) => {
+  const t = ["component", e.plugin, e.resource, e.area];
+  return {
+    /**
+     * Fetch result for the resource. The client will automatically cache the result, and update the cache
+     * when the resource is updated or deleted via the returned update and remove mutation functions.
+     */
+    component: D({
+      queryKey: t,
+      queryFn: async () => Cn(e)
+    })
+  };
+}, Us = ({ pluginID: e, connectionID: t }) => {
+  const n = P(e);
+  return {
+    /**
+     * The current settings from the provider.
+     */
+    groups: D({
+      queryKey: [n, "resource_groups", "list"],
+      queryFn: async () => En(n, t),
+      retry: !1
+    })
+  };
+}, js = ({
+  pluginID: e,
+  connectionID: t,
+  searches: n
+}) => {
+  const r = P(e), s = (o) => [r, t, o.key, o.namespaces, "list"];
+  return Tn({
+    queries: n.map((o) => ({
+      queryKey: s(o),
+      queryFn: async () => ht(r, t, o.key, T.ListInput.createFrom({
+        params: {},
+        order: {
+          by: "name",
+          direction: !0
+        },
+        pagination: {
+          page: 1,
+          pageSize: 200
+        },
+        namespaces: o.namespaces
+      })).then((a) => (console.log(a.result), a.result && o.postFilter ? Object.values(a.result).filter(o.postFilter) : Object.values(a.result || {}))),
+      retry: !1
+    }))
+  });
+}, Qs = ({ pluginID: e, resourceKey: t }) => {
+  const n = P(e);
+  return {
+    /**
+     * The current settings from the provider.
+     */
+    resourceType: D({
+      queryKey: [n, "resources", t],
+      queryFn: async () => bn(n, t),
+      retry: !1
+    })
+  };
+}, zs = ({ pluginID: e, connectionID: t }) => {
+  const n = P(e);
+  return {
+    /**
+     * The current settings from the provider.
+     */
+    types: D({
+      queryKey: [n, "resources", "list"],
+      queryFn: async () => vn(n, t),
+      retry: !1
+    })
+  };
+};
+var Tt = Symbol.for("immer-nothing"), tt = Symbol.for("immer-draftable"), N = Symbol.for("immer-state"), Vn = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(e) {
+    return `The plugin for '${e}' has not been loaded into Immer. To enable the plugin, import and call \`enable${e}()\` when initializing your application.`;
+  },
+  function(e) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${e}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(e) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + e;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(e) {
+    return `'current' expects a draft, got: ${e}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(e) {
+    return `'original' expects a draft, got: ${e}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function O(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const n = Vn[e], r = typeof n == "function" ? n.apply(null, t) : n;
+    throw new Error(`[Immer] ${r}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var Z = Object.getPrototypeOf;
+function ee(e) {
+  return !!e && !!e[N];
+}
+function Q(e) {
+  var t;
+  return e ? Nt(e) || Array.isArray(e) || !!e[tt] || !!((t = e.constructor) != null && t[tt]) || _e(e) || we(e) : !1;
+}
+var Xn = Object.prototype.constructor.toString();
+function Nt(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = Z(e);
+  if (t === null)
+    return !0;
+  const n = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
+  return n === Object ? !0 : typeof n == "function" && Function.toString.call(n) === Xn;
+}
+function pe(e, t) {
+  ge(e) === 0 ? Reflect.ownKeys(e).forEach((n) => {
+    t(n, e[n], e);
+  }) : e.forEach((n, r) => t(r, n, e));
+}
+function ge(e) {
+  const t = e[N];
+  return t ? t.type_ : Array.isArray(e) ? 1 : _e(e) ? 2 : we(e) ? 3 : 0;
+}
+function Ae(e, t) {
+  return ge(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function kt(e, t, n) {
+  const r = ge(e);
+  r === 2 ? e.set(t, n) : r === 3 ? e.add(n) : e[t] = n;
+}
+function Zn(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function _e(e) {
+  return e instanceof Map;
+}
+function we(e) {
+  return e instanceof Set;
+}
+function U(e) {
+  return e.copy_ || e.base_;
+}
+function Te(e, t) {
+  if (_e(e))
+    return new Map(e);
+  if (we(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  const n = Nt(e);
+  if (t === !0 || t === "class_only" && !n) {
+    const r = Object.getOwnPropertyDescriptors(e);
+    delete r[N];
+    let s = Reflect.ownKeys(r);
+    for (let i = 0; i < s.length; i++) {
+      const o = s[i], a = r[o];
+      a.writable === !1 && (a.writable = !0, a.configurable = !0), (a.get || a.set) && (r[o] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: a.enumerable,
+        value: e[o]
+      });
+    }
+    return Object.create(Z(e), r);
+  } else {
+    const r = Z(e);
+    if (r !== null && n)
+      return { ...e };
+    const s = Object.create(r);
+    return Object.assign(s, e);
+  }
+}
+function Ge(e, t = !1) {
+  return Se(e) || ee(e) || !Q(e) || (ge(e) > 1 && (e.set = e.add = e.clear = e.delete = er), Object.freeze(e), t && Object.entries(e).forEach(([n, r]) => Ge(r, !0))), e;
+}
+function er() {
+  O(2);
+}
+function Se(e) {
+  return Object.isFrozen(e);
+}
+var tr = {};
+function z(e) {
+  const t = tr[e];
+  return t || O(0, e), t;
+}
+var re;
+function Rt() {
+  return re;
+}
+function nr(e, t) {
+  return {
+    drafts_: [],
+    parent_: e,
+    immer_: t,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: !0,
+    unfinalizedDrafts_: 0
+  };
+}
+function nt(e, t) {
+  t && (z("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function Ne(e) {
+  ke(e), e.drafts_.forEach(rr), e.drafts_ = null;
+}
+function ke(e) {
+  e === re && (re = e.parent_);
+}
+function rt(e) {
+  return re = nr(re, e);
+}
+function rr(e) {
+  const t = e[N];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function st(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const n = t.drafts_[0];
+  return e !== void 0 && e !== n ? (n[N].modified_ && (Ne(t), O(4)), Q(e) && (e = ye(t, e), t.parent_ || he(t, e)), t.patches_ && z("Patches").generateReplacementPatches_(
+    n[N].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = ye(t, n, []), Ne(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== Tt ? e : void 0;
+}
+function ye(e, t, n) {
+  if (Se(t))
+    return t;
+  const r = t[N];
+  if (!r)
+    return pe(
+      t,
+      (s, i) => ot(e, r, t, s, i, n)
+    ), t;
+  if (r.scope_ !== e)
+    return t;
+  if (!r.modified_)
+    return he(e, r.base_, !0), r.base_;
+  if (!r.finalized_) {
+    r.finalized_ = !0, r.scope_.unfinalizedDrafts_--;
+    const s = r.copy_;
+    let i = s, o = !1;
+    r.type_ === 3 && (i = new Set(s), s.clear(), o = !0), pe(
+      i,
+      (a, c) => ot(e, r, s, a, c, n, o)
+    ), he(e, s, !1), n && e.patches_ && z("Patches").generatePatches_(
+      r,
+      n,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return r.copy_;
+}
+function ot(e, t, n, r, s, i, o) {
+  if (process.env.NODE_ENV !== "production" && s === n && O(5), ee(s)) {
+    const a = i && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+    !Ae(t.assigned_, r) ? i.concat(r) : void 0, c = ye(e, s, a);
+    if (kt(n, r, c), ee(c))
+      e.canAutoFreeze_ = !1;
+    else
+      return;
+  } else o && n.add(s);
+  if (Q(s) && !Se(s)) {
+    if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1)
+      return;
+    ye(e, s), (!t || !t.scope_.parent_) && typeof r != "symbol" && Object.prototype.propertyIsEnumerable.call(n, r) && he(e, s);
+  }
+}
+function he(e, t, n = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && Ge(t, n);
+}
+function sr(e, t) {
+  const n = Array.isArray(e), r = {
+    type_: n ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : Rt(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: t,
+    // The base state.
+    base_: e,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1
+  };
+  let s = r, i = Ke;
+  n && (s = [r], i = se);
+  const { revoke: o, proxy: a } = Proxy.revocable(s, i);
+  return r.draft_ = a, r.revoke_ = o, a;
+}
+var Ke = {
+  get(e, t) {
+    if (t === N)
+      return e;
+    const n = U(e);
+    if (!Ae(n, t))
+      return or(e, n, t);
+    const r = n[t];
+    return e.finalized_ || !Q(r) ? r : r === Pe(e.base_, t) ? (De(e), e.copy_[t] = Me(r, e)) : r;
+  },
+  has(e, t) {
+    return t in U(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(U(e));
+  },
+  set(e, t, n) {
+    const r = Mt(U(e), t);
+    if (r != null && r.set)
+      return r.set.call(e.draft_, n), !0;
+    if (!e.modified_) {
+      const s = Pe(U(e), t), i = s == null ? void 0 : s[N];
+      if (i && i.base_ === n)
+        return e.copy_[t] = n, e.assigned_[t] = !1, !0;
+      if (Zn(n, s) && (n !== void 0 || Ae(e.base_, t)))
+        return !0;
+      De(e), Re(e);
+    }
+    return e.copy_[t] === n && // special case: handle new props with value 'undefined'
+    (n !== void 0 || t in e.copy_) || // special case: NaN
+    Number.isNaN(n) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = n, e.assigned_[t] = !0), !0;
+  },
+  deleteProperty(e, t) {
+    return Pe(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, De(e), Re(e)) : delete e.assigned_[t], e.copy_ && delete e.copy_[t], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(e, t) {
+    const n = U(e), r = Reflect.getOwnPropertyDescriptor(n, t);
+    return r && {
+      writable: !0,
+      configurable: e.type_ !== 1 || t !== "length",
+      enumerable: r.enumerable,
+      value: n[t]
+    };
+  },
+  defineProperty() {
+    O(11);
+  },
+  getPrototypeOf(e) {
+    return Z(e.base_);
+  },
+  setPrototypeOf() {
+    O(12);
+  }
+}, se = {};
+pe(Ke, (e, t) => {
+  se[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+se.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && O(13), se.set.call(this, e, t, void 0);
+};
+se.set = function(e, t, n) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && O(14), Ke.set.call(this, e[0], t, n, e[0]);
+};
+function Pe(e, t) {
+  const n = e[N];
+  return (n ? U(n) : e)[t];
+}
+function or(e, t, n) {
+  var s;
+  const r = Mt(t, n);
+  return r ? "value" in r ? r.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    (s = r.get) == null ? void 0 : s.call(e.draft_)
+  ) : void 0;
+}
+function Mt(e, t) {
+  if (!(t in e))
+    return;
+  let n = Z(e);
+  for (; n; ) {
+    const r = Object.getOwnPropertyDescriptor(n, t);
+    if (r)
+      return r;
+    n = Z(n);
+  }
+}
+function Re(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && Re(e.parent_));
+}
+function De(e) {
+  e.copy_ || (e.copy_ = Te(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var ir = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.produce = (t, n, r) => {
+      if (typeof t == "function" && typeof n != "function") {
+        const i = n;
+        n = t;
+        const o = this;
+        return function(c = i, ...l) {
+          return o.produce(c, (u) => n.call(this, u, ...l));
+        };
+      }
+      typeof n != "function" && O(6), r !== void 0 && typeof r != "function" && O(7);
+      let s;
+      if (Q(t)) {
+        const i = rt(this), o = Me(t, void 0);
+        let a = !0;
+        try {
+          s = n(o), a = !1;
+        } finally {
+          a ? Ne(i) : ke(i);
+        }
+        return nt(i, r), st(s, i);
+      } else if (!t || typeof t != "object") {
+        if (s = n(t), s === void 0 && (s = t), s === Tt && (s = void 0), this.autoFreeze_ && Ge(s, !0), r) {
+          const i = [], o = [];
+          z("Patches").generateReplacementPatches_(t, s, i, o), r(i, o);
+        }
+        return s;
+      } else
+        O(1, t);
+    }, this.produceWithPatches = (t, n) => {
+      if (typeof t == "function")
+        return (o, ...a) => this.produceWithPatches(o, (c) => t(c, ...a));
+      let r, s;
+      return [this.produce(t, n, (o, a) => {
+        r = o, s = a;
+      }), r, s];
+    }, typeof (e == null ? void 0 : e.autoFreeze) == "boolean" && this.setAutoFreeze(e.autoFreeze), typeof (e == null ? void 0 : e.useStrictShallowCopy) == "boolean" && this.setUseStrictShallowCopy(e.useStrictShallowCopy);
+  }
+  createDraft(e) {
+    Q(e) || O(8), ee(e) && (e = ar(e));
+    const t = rt(this), n = Me(e, void 0);
+    return n[N].isManual_ = !0, ke(t), n;
+  }
+  finishDraft(e, t) {
+    const n = e && e[N];
+    (!n || !n.isManual_) && O(9);
+    const { scope_: r } = n;
+    return nt(r, t), st(void 0, r);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(e) {
+    this.autoFreeze_ = e;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(e) {
+    this.useStrictShallowCopy_ = e;
+  }
+  applyPatches(e, t) {
+    let n;
+    for (n = t.length - 1; n >= 0; n--) {
+      const s = t[n];
+      if (s.path.length === 0 && s.op === "replace") {
+        e = s.value;
+        break;
+      }
+    }
+    n > -1 && (t = t.slice(n + 1));
+    const r = z("Patches").applyPatches_;
+    return ee(e) ? r(e, t) : this.produce(
+      e,
+      (s) => r(s, t)
+    );
+  }
+};
+function Me(e, t) {
+  const n = _e(e) ? z("MapSet").proxyMap_(e, t) : we(e) ? z("MapSet").proxySet_(e, t) : sr(e, t);
+  return (t ? t.scope_ : Rt()).drafts_.push(n), n;
+}
+function ar(e) {
+  return ee(e) || O(10, e), $t(e);
+}
+function $t(e) {
+  if (!Q(e) || Se(e))
+    return e;
+  const t = e[N];
+  let n;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, n = Te(e, t.scope_.immer_.useStrictShallowCopy_);
+  } else
+    n = Te(e, !0);
+  return pe(n, (r, s) => {
+    kt(n, r, $t(s));
+  }), t && (t.finalized_ = !1), n;
+}
+var k = new ir(), le = k.produce;
+k.produceWithPatches.bind(
+  k
+);
+k.setAutoFreeze.bind(k);
+k.setUseStrictShallowCopy.bind(k);
+k.applyPatches.bind(k);
+k.createDraft.bind(k);
+k.finishDraft.bind(k);
+var ue = typeof globalThis < "u" ? globalThis : typeof window < "u" ? window : typeof global < "u" ? global : typeof self < "u" ? self : {};
+function cr(e) {
+  return e && e.__esModule && Object.prototype.hasOwnProperty.call(e, "default") ? e.default : e;
+}
+var ur = "Expected a function", Lt = "__lodash_hash_undefined__", lr = "[object Function]", dr = "[object GeneratorFunction]", fr = "[object Symbol]", pr = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, yr = /^\w*$/, hr = /^\./, mr = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g, gr = /[\\^$.*+?()[\]{}|]/g, _r = /\\(\\)?/g, wr = /^\[object .+?Constructor\]$/, Sr = typeof ue == "object" && ue && ue.Object === Object && ue, Cr = typeof self == "object" && self && self.Object === Object && self, Ue = Sr || Cr || Function("return this")();
+function Er(e, t) {
+  return e == null ? void 0 : e[t];
+}
+function br(e) {
+  var t = !1;
+  if (e != null && typeof e.toString != "function")
+    try {
+      t = !!(e + "");
+    } catch {
+    }
+  return t;
+}
+var vr = Array.prototype, Pr = Function.prototype, qt = Object.prototype, Fe = Ue["__core-js_shared__"], it = function() {
+  var e = /[^.]+$/.exec(Fe && Fe.keys && Fe.keys.IE_PROTO || "");
+  return e ? "Symbol(src)_1." + e : "";
+}(), Gt = Pr.toString, je = qt.hasOwnProperty, Kt = qt.toString, Dr = RegExp(
+  "^" + Gt.call(je).replace(gr, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+), at = Ue.Symbol, Fr = vr.splice, xr = Ut(Ue, "Map"), oe = Ut(Object, "create"), ct = at ? at.prototype : void 0, ut = ct ? ct.toString : void 0;
+function W(e) {
+  var t = -1, n = e ? e.length : 0;
+  for (this.clear(); ++t < n; ) {
+    var r = e[t];
+    this.set(r[0], r[1]);
+  }
+}
+function Ir() {
+  this.__data__ = oe ? oe(null) : {};
+}
+function Or(e) {
+  return this.has(e) && delete this.__data__[e];
+}
+function Ar(e) {
+  var t = this.__data__;
+  if (oe) {
+    var n = t[e];
+    return n === Lt ? void 0 : n;
+  }
+  return je.call(t, e) ? t[e] : void 0;
+}
+function Tr(e) {
+  var t = this.__data__;
+  return oe ? t[e] !== void 0 : je.call(t, e);
+}
+function Nr(e, t) {
+  var n = this.__data__;
+  return n[e] = oe && t === void 0 ? Lt : t, this;
+}
+W.prototype.clear = Ir;
+W.prototype.delete = Or;
+W.prototype.get = Ar;
+W.prototype.has = Tr;
+W.prototype.set = Nr;
+function ne(e) {
+  var t = -1, n = e ? e.length : 0;
+  for (this.clear(); ++t < n; ) {
+    var r = e[t];
+    this.set(r[0], r[1]);
+  }
+}
+function kr() {
+  this.__data__ = [];
+}
+function Rr(e) {
+  var t = this.__data__, n = Ce(t, e);
+  if (n < 0)
+    return !1;
+  var r = t.length - 1;
+  return n == r ? t.pop() : Fr.call(t, n, 1), !0;
+}
+function Mr(e) {
+  var t = this.__data__, n = Ce(t, e);
+  return n < 0 ? void 0 : t[n][1];
+}
+function $r(e) {
+  return Ce(this.__data__, e) > -1;
+}
+function Lr(e, t) {
+  var n = this.__data__, r = Ce(n, e);
+  return r < 0 ? n.push([e, t]) : n[r][1] = t, this;
+}
+ne.prototype.clear = kr;
+ne.prototype.delete = Rr;
+ne.prototype.get = Mr;
+ne.prototype.has = $r;
+ne.prototype.set = Lr;
+function H(e) {
+  var t = -1, n = e ? e.length : 0;
+  for (this.clear(); ++t < n; ) {
+    var r = e[t];
+    this.set(r[0], r[1]);
+  }
+}
+function qr() {
+  this.__data__ = {
+    hash: new W(),
+    map: new (xr || ne)(),
+    string: new W()
+  };
+}
+function Gr(e) {
+  return Ee(this, e).delete(e);
+}
+function Kr(e) {
+  return Ee(this, e).get(e);
+}
+function Ur(e) {
+  return Ee(this, e).has(e);
+}
+function jr(e, t) {
+  return Ee(this, e).set(e, t), this;
+}
+H.prototype.clear = qr;
+H.prototype.delete = Gr;
+H.prototype.get = Kr;
+H.prototype.has = Ur;
+H.prototype.set = jr;
+function Ce(e, t) {
+  for (var n = e.length; n--; )
+    if (es(e[n][0], t))
+      return n;
+  return -1;
+}
+function Qr(e, t) {
+  t = Br(t, e) ? [t] : Hr(t);
+  for (var n = 0, r = t.length; e != null && n < r; )
+    e = e[Xr(t[n++])];
+  return n && n == r ? e : void 0;
+}
+function zr(e) {
+  if (!Qt(e) || Jr(e))
+    return !1;
+  var t = ts(e) || br(e) ? Dr : wr;
+  return t.test(Zr(e));
+}
+function Wr(e) {
+  if (typeof e == "string")
+    return e;
+  if (ze(e))
+    return ut ? ut.call(e) : "";
+  var t = e + "";
+  return t == "0" && 1 / e == -1 / 0 ? "-0" : t;
+}
+function Hr(e) {
+  return jt(e) ? e : Vr(e);
+}
+function Ee(e, t) {
+  var n = e.__data__;
+  return Yr(t) ? n[typeof t == "string" ? "string" : "hash"] : n.map;
+}
+function Ut(e, t) {
+  var n = Er(e, t);
+  return zr(n) ? n : void 0;
+}
+function Br(e, t) {
+  if (jt(e))
+    return !1;
+  var n = typeof e;
+  return n == "number" || n == "symbol" || n == "boolean" || e == null || ze(e) ? !0 : yr.test(e) || !pr.test(e) || t != null && e in Object(t);
+}
+function Yr(e) {
+  var t = typeof e;
+  return t == "string" || t == "number" || t == "symbol" || t == "boolean" ? e !== "__proto__" : e === null;
+}
+function Jr(e) {
+  return !!it && it in e;
+}
+var Vr = Qe(function(e) {
+  e = rs(e);
+  var t = [];
+  return hr.test(e) && t.push(""), e.replace(mr, function(n, r, s, i) {
+    t.push(s ? i.replace(_r, "$1") : r || n);
+  }), t;
+});
+function Xr(e) {
+  if (typeof e == "string" || ze(e))
+    return e;
+  var t = e + "";
+  return t == "0" && 1 / e == -1 / 0 ? "-0" : t;
+}
+function Zr(e) {
+  if (e != null) {
+    try {
+      return Gt.call(e);
+    } catch {
+    }
+    try {
+      return e + "";
+    } catch {
+    }
+  }
+  return "";
+}
+function Qe(e, t) {
+  if (typeof e != "function" || t && typeof t != "function")
+    throw new TypeError(ur);
+  var n = function() {
+    var r = arguments, s = t ? t.apply(this, r) : r[0], i = n.cache;
+    if (i.has(s))
+      return i.get(s);
+    var o = e.apply(this, r);
+    return n.cache = i.set(s, o), o;
+  };
+  return n.cache = new (Qe.Cache || H)(), n;
+}
+Qe.Cache = H;
+function es(e, t) {
+  return e === t || e !== e && t !== t;
+}
+var jt = Array.isArray;
+function ts(e) {
+  var t = Qt(e) ? Kt.call(e) : "";
+  return t == lr || t == dr;
+}
+function Qt(e) {
+  var t = typeof e;
+  return !!e && (t == "object" || t == "function");
+}
+function ns(e) {
+  return !!e && typeof e == "object";
+}
+function ze(e) {
+  return typeof e == "symbol" || ns(e) && Kt.call(e) == fr;
+}
+function rs(e) {
+  return e == null ? "" : Wr(e);
+}
+function ss(e, t, n) {
+  var r = e == null ? void 0 : Qr(e, t);
+  return r === void 0 ? n : r;
+}
+var os = ss;
+const Y = /* @__PURE__ */ cr(os), Ws = ({
+  pluginID: e,
+  connectionID: t,
+  resourceKey: n,
+  idAccessor: r,
+  namespaces: s = [],
+  listParams: i = {},
+  createParams: o = {}
+}) => {
+  const a = P(e), c = G(), { showSnackbar: l } = $(), u = [a, t, n, s, "list"], y = (d, g) => [a, t, n, g, d];
+  console.log("getting from key: ", `${a}/${t}/${n}`);
+  const { mutateAsync: h } = v({
+    mutationFn: async (d) => mt(a, t, n, T.CreateInput.createFrom({
+      params: d.params || o,
+      input: d.input,
+      namespaces: s
+    })),
+    onSuccess: async (d) => {
+      var C, R, ie, B, L, We, He, Be;
+      let g = "";
+      (C = d.result.metadata) != null && C.name ? g = d.result.metadata.name : (R = d.result) != null && R.id ? g = (ie = d.result) == null ? void 0 : ie.id : (B = d.result) != null && B.name ? g = (L = d.result) == null ? void 0 : L.name : (We = d.result) != null && We.ID ? g = (He = d.result) == null ? void 0 : He.ID : (Be = d.result) != null && Be.Name && (g = d.result.Name);
+      const E = g ? `Resource ${g} created` : "Resource created";
+      l(E, "success"), await c.invalidateQueries({ queryKey: u });
+    },
+    onError: I(l, "Failed to create resource")
+  }), f = D({
+    queryKey: u,
+    queryFn: async () => ht(a, t, n, T.ListInput.createFrom({
+      params: i,
+      order: {
+        by: "name",
+        direction: !0
+      },
+      pagination: {
+        page: 1,
+        pageSize: 200
+      },
+      namespaces: s
+    })),
+    placeholderData: (d, g) => d,
+    retry: !1
+  }), m = _.useCallback((d) => {
+    console.log("got a new resource", d), r && (c.setQueryData(u, (g) => le(g, (E) => {
+      if (E || (E = T.ListResult.createFrom({
+        result: [],
+        success: !0,
+        pagination: {}
+      })), E.result.findIndex((R) => Y(d.data, r) === Y(R, r)) === -1) {
+        E.result.push(d.data);
+        return;
+      }
+    })), c.setQueryData(y(d.id, d.namespace), { result: d.data }));
+  }, []), p = _.useCallback((d) => {
+    console.log("got an updated resource", d), r && (c.setQueryData(u, (g) => le(g, (E) => {
+      E || (E = T.ListResult.createFrom({
+        result: [],
+        success: !0,
+        pagination: {}
+      }));
+      const C = E.result.findIndex((R) => Y(d.newData, r) === Y(R, r));
+      if (C !== -1) {
+        E.result[C] = d.newData;
+        return;
+      }
+    })), c.setQueryData(y(d.id, d.namespace), { result: d.newData }));
+  }, []), S = _.useCallback((d) => {
+    console.log("got a deleted resource", d), r && c.setQueryData(u, (g) => le(g, (E) => {
+      if (!E)
+        return;
+      const C = E.result.findIndex((R) => Y(d.data, r) === Y(R, r));
+      if (C !== -1) {
+        E.result.splice(C, 1);
+        return;
+      }
+    }));
+  }, []);
+  _.useEffect(() => {
+    if (!r)
+      return;
+    const d = A(`${a}/${t}/${n}/ADD`, m), g = A(`${a}/${t}/${n}/UPDATE`, p), E = A(`${a}/${t}/${n}/DELETE`, S);
+    return () => {
+      d(), g(), E();
+    };
+  }, []);
+  const [w, b] = _.useState(
+    x.Pending
+  );
+  return _.useEffect(() => A(
+    `${a}/${t}/informer/STATE`,
+    (g) => {
+      g.resourceKey === n && b(g.state);
+    }
+  ), [a, t, n]), {
+    /**
+     * Fetch result for the resource. The client will automatically cache the result, and update the cache
+     * when the resources are updated or deleted via the returned create and remove mutation functions, or
+     * the per-resource hook mutation functions.
+     */
+    resources: f,
+    /**
+     * Create a new resource. A set of optional parameters can be passed to customize the create behavior,
+     * which if specified, will add additional default behavior set via the hook options.
+     *
+     * @params opts Optional parameters to pass to the resource create operation
+     */
+    create: h,
+    /** Current informer state for this resource type */
+    informerState: w,
+    /** Whether the informer is currently syncing */
+    isSyncing: w === x.Syncing,
+    /** Whether the informer has fully synced */
+    isSynced: w === x.Synced,
+    /** Whether the informer encountered an error */
+    informerError: w === x.Error
+  };
+}, Hs = ({ pluginID: e }) => {
+  const t = P(e), { showSnackbar: n } = $(), r = v({
+    mutationFn: async ({ opts: o, input: a }) => mt(
+      t,
+      o.connectionID,
+      o.resourceKey,
+      T.CreateInput.createFrom({
+        params: { ...o.params, ...a.params },
+        input: { ...o.params, ...a.input },
+        id: o.resourceID,
+        namespace: o.namespace
+      })
+    ),
+    onSuccess: (o, { opts: a }) => {
+      n(`Resource ${a.resourceID} created`, "success");
+    },
+    onError(o, { opts: a }) {
+      X(n, o, `Failed to create resource ${a.resourceID}`);
+    }
+  }), s = v({
+    mutationFn: async ({ opts: o, input: a }) => pt(
+      t,
+      o.connectionID,
+      o.resourceKey,
+      T.UpdateInput.createFrom({
+        params: { ...o.params, ...a.params },
+        input: { ...o.params, ...a.input },
+        id: o.resourceID,
+        namespace: o.namespace
+      })
+    ),
+    onSuccess: (o, { opts: a }) => {
+      n(`Resource ${a.resourceID} updated`, "success");
+    },
+    onError(o, { opts: a }) {
+      X(n, o, `Failed to update resource ${a.resourceID}`);
+    }
+  }), i = v({
+    mutationFn: async ({ opts: o, input: a }) => yt(
+      t,
+      o.connectionID,
+      o.resourceKey,
+      T.DeleteInput.createFrom({
+        ...a,
+        params: { ...o.params, ...a.params },
+        input: { ...o.params, ...a.input },
+        id: o.resourceID,
+        namespace: o.namespace
+      })
+    ),
+    onSuccess: (o, { opts: a }) => {
+      n(`Resource ${a.resourceID} deleted`, "success");
+    },
+    onError(o, { opts: a }) {
+      X(n, o, `Failed to delete resource ${a.resourceID}`);
+    }
+  });
+  return {
+    create: r.mutateAsync,
+    update: s.mutateAsync,
+    remove: i.mutateAsync
+  };
+}, Bs = ({
+  pluginID: e,
+  connectionID: t,
+  resourceKey: n,
+  enabled: r = !0
+}) => {
+  const s = P(e), i = D({
+    queryKey: ["RESOURCE_ACTIONS", s, t, n],
+    queryFn: () => Pn(s, t, n),
+    enabled: r && !!s && !!t && !!n,
+    staleTime: 5 * 60 * 1e3
+    // actions don't change often
+  });
+  return {
+    actions: i.data ?? [],
+    isLoading: i.isLoading,
+    error: i.error
+  };
+}, Ys = ({
+  pluginID: e,
+  connectionID: t,
+  resourceKey: n
+}) => {
+  const r = P(e), s = G(), { showSnackbar: i } = $(), o = v({
+    mutationFn: async ({ actionID: a, id: c = "", namespace: l = "", params: u = {} }) => Dn(
+      r,
+      t,
+      n,
+      a,
+      T.ActionInput.createFrom({ id: c, namespace: l, params: u })
+    ),
+    onSuccess: (a) => {
+      a.message && i(a.message, "success"), s.invalidateQueries({
+        queryKey: ["RESOURCES", r, t, n]
+      });
+    },
+    onError: (a, c) => {
+      X(i, a, `Failed to execute action "${c.actionID}"`);
+    }
+  });
+  return {
+    executeAction: o.mutateAsync,
+    isExecuting: o.isPending,
+    error: o.error
+  };
+}, Js = ({
+  pluginID: e,
+  connectionID: t,
+  enabled: n = !0
+}) => {
+  const r = P(e), s = D({
+    queryKey: ["EDITOR_SCHEMAS", r, t],
+    queryFn: () => Fn(r, t),
+    enabled: n && !!r && !!t,
+    staleTime: 10 * 60 * 1e3,
+    // schemas are fairly stable per connection
+    retry: 1
+  });
+  return {
+    schemas: s.data ?? [],
+    isLoading: s.isLoading,
+    error: s.error,
+    refetch: s.refetch
+  };
+}, Vs = ({
+  pluginID: e,
+  connectionID: t,
+  enabled: n = !0
+}) => {
+  const r = P(e), s = G(), i = [r, t, "informer-state"], o = D({
+    queryKey: i,
+    queryFn: () => xn(r, t),
+    enabled: n && !!r && !!t
+  });
+  j(() => !n || !r || !t ? void 0 : A(
+    `${r}/${t}/informer/STATE`,
+    (u) => {
+      s.setQueryData(i, (y) => y && le(y, (h) => {
+        h.resources[u.resourceKey] = u.state, h.resourceCounts[u.resourceKey] = u.resourceCount;
+        let f = 0, m = 0;
+        for (const p of Object.values(h.resources))
+          p === x.Synced && f++, p === x.Error && m++;
+        h.syncedCount = f, h.errorCount = m;
+      }));
+    }
+  ), [r, t, n]);
+  const a = o.data;
+  let c = 0;
+  if (a != null && a.resources)
+    for (const l of Object.values(a.resources))
+      (l === x.Synced || l === x.Error || l === x.Cancelled) && c++;
+  return {
+    /** Full summary query result */
+    summary: o,
+    /** Get the state of a specific resource type's informer */
+    getResourceState: (l) => a == null ? void 0 : a.resources[l],
+    /** Whether all registered informers have reached a terminal state */
+    isFullySynced: a ? a.totalResources > 0 && c === a.totalResources : !1,
+    /** Sync progress as a 0-1 fraction (terminal states / total) */
+    syncProgress: a && a.totalResources > 0 ? c / a.totalResources : 0,
+    /** Number of informers that encountered errors */
+    errorCount: (a == null ? void 0 : a.errorCount) ?? 0
+  };
+}, Xs = () => {
+  const [e, t] = q(/* @__PURE__ */ new Map()), n = de(/* @__PURE__ */ new Map()), r = de(/* @__PURE__ */ new Map()), s = V((l) => {
+    const u = qe(l), y = Ot(n.current, l), h = Ft(y);
+    if (t((f) => {
+      const m = new Map(f);
+      return m.set(u, h), m;
+    }), r.current.has(u) && (clearTimeout(r.current.get(u)), r.current.delete(u)), fe(h)) {
+      const f = setTimeout(() => {
+        t((m) => {
+          const p = new Map(m);
+          return p.delete(u), p;
+        }), n.current.delete(u), r.current.delete(u);
+      }, 5e3);
+      r.current.set(u, f);
+    }
+  }, []);
+  j(() => {
+    const l = A("informer/STATE", s);
+    return () => {
+      l();
+      for (const u of r.current.values())
+        clearTimeout(u);
+    };
+  }, [s]);
+  const i = Array.from(e.values()), o = xt(i), a = i.find((l) => !fe(l)) ?? i[0] ?? null, c = It(i);
+  return {
+    /** All tracked syncs */
+    syncs: i,
+    /** Whether any connection is actively syncing */
+    hasSyncing: o,
+    /** The primary (first incomplete) sync or most recent */
+    primarySync: a,
+    /** Aggregate progress across all connections (0-1) */
+    aggregateProgress: c
+  };
+}, is = () => {
+  const e = _.useContext(Et);
+  if (!e) throw new Error("useOperations must be used within an OperationsProvider");
+  return e;
+}, Zs = ({
+  pluginID: e,
+  connectionID: t,
+  resourceKey: n
+}) => {
+  const r = P(e), { showSnackbar: s } = $(), { addOperation: i, updateOperation: o } = is(), a = _.useRef([]);
+  return _.useEffect(() => () => {
+    a.current.forEach((l) => l());
+  }, []), { startStreamAction: _.useCallback(
+    async ({ actionID: l, id: u, namespace: y, label: h, params: f = {} }) => {
+      try {
+        const m = await In(
+          r,
+          t,
+          n,
+          l,
+          T.ActionInput.createFrom({ id: u, namespace: y, params: f })
+        );
+        i({
+          id: m,
+          label: h,
+          resourceKey: n,
+          resourceName: u,
+          namespace: y,
+          connectionID: t,
+          status: "running",
+          startedAt: Date.now()
+        });
+        const p = `action/stream/${m}`, S = A(p, (w) => {
+          var b, d, g, E;
+          switch (w.type) {
+            case "progress": {
+              const C = w.data ?? {};
+              o(m, {
+                message: C.message,
+                progress: C.ready !== void 0 && C.desired !== void 0 ? { ready: C.ready, desired: C.desired } : void 0
+              });
+              break;
+            }
+            case "complete":
+              o(m, {
+                status: "completed",
+                message: ((b = w.data) == null ? void 0 : b.message) ?? "Completed",
+                completedAt: Date.now()
+              }), s(((d = w.data) == null ? void 0 : d.message) ?? h + " completed", "success"), be(p);
+              break;
+            case "error":
+              o(m, {
+                status: "error",
+                message: ((g = w.data) == null ? void 0 : g.message) ?? "Failed",
+                completedAt: Date.now()
+              }), s(((E = w.data) == null ? void 0 : E.message) ?? h + " failed", "error"), be(p);
+              break;
+          }
+        });
+        return a.current.push(() => {
+          S(), be(p);
+        }), m;
+      } catch (m) {
+        throw X(s, m, `Failed to start "${l}"`), m;
+      }
+    },
+    [r, t, n, i, o, s]
+  ) };
+}, eo = () => {
+  const e = _.useContext(Ct);
+  if (!e)
+    throw new Error("useSettings must be used within a SettingsProvider");
+  return e;
+}, to = ({ to: e, withinContext: t, ...n }) => {
+  const { meta: r } = Le();
+  r.id || console.error("Link used outside of a plugin context");
+  const s = `/_plugin/${r.id}${e.startsWith("/") ? "" : "/"}${e}`;
+  return _.useMemo(() => /* @__PURE__ */ F(Bt, { style: { textDecoration: "none", color: "inherit" }, ...n, to: s }), [n, s]);
+};
+function no() {
+  const e = Yt(), t = Jt(), { meta: n } = Le();
+  n.id || console.error("usePluginRouter used outside of a plugin context");
+  const r = `/_plugin/${n.id}`, s = t.pathname.startsWith(r) ? t.pathname.slice(r.length) || "/" : t.pathname, i = (o, a) => {
+    const { ...c } = a ?? {};
+    o.startsWith("/") ? e(`${r}${o}`, c) : e(o, c);
+  };
+  return Ht(() => ({
+    location: t,
+    navigate: i,
+    pluginPath: s
+  }), [t.pathname]);
+}
+class ro {
+}
+class so {
+  constructor() {
+    M(this, "_extensions");
+    /**
+     * The root component to render for the application window.
+     */
+    M(this, "root");
+    /**
+     * Various pages to render under the root component. These can be navigated to using
+     * the built-in navigation system both programatically and through Links.
+     *
+     * @example
+     * Programatically:
+     * ```
+     * import { usePluginNavigation } from '@omniviewdev/runtime';
+     * const MyComponent = () => {
+     *  const { navigate } = usePluginNavigation();
+     *
+     *  const goToPage = () => {
+     *      navigate('some-page')
+     *  }
+     *
+     * }
+     * ```
+     *
+     * Using Links:
+     * ```
+     * import { Link } from '@omniviewdev/runtime';
+     * const MyComponent = () => {
+     *  return (
+     *    <Link to="some-page">
+     *  )
+     * }
+     * ```
+     * 
+     */
+    M(this, "pages");
+    M(this, "_routes");
+  }
+  get extensions() {
+    return this._extensions || [];
+  }
+  get Routes() {
+    var t;
+    if (!this._routes && this.root)
+      return [{
+        path: "",
+        index: !0,
+        Component: this.root
+      }];
+    if (!((t = this._routes) != null && t.length))
+      throw new Error("cannot use plugin without a root page or router");
+    return this._routes;
+  }
+  /**
+   * Get's the route provider component to render within the plugin view
+   */
+  get Window() {
+    if (!this._routes && this.root)
+      return /* @__PURE__ */ F(this.root, {});
+    const t = Vt(this._routes || []);
+    return /* @__PURE__ */ F(Xt, { router: t });
+  }
+  /**
+   * Register extension points for other plugins to extend the functionality
+   * of the plugin. All extension points registered will be name as such:
+   *
+   * `${plugin_id}/${extension_point_id}`
+   */
+  registerExtensionPoints(t) {
+    return this._extensions = t || [], this;
+  }
+  /**
+   * Set the component displayed under:
+   *   /_plugin/${plugin_id}/*
+   *
+   * If the NavModel is configured, the page will have a managed frame, otheriwse it has full control.
+   */
+  setRootPage(t) {
+    return this.root = t, this;
+  }
+  /**
+   * Adds a page to the plugin window. This page will be displayed under:
+   */
+  withPage(t, n) {
+    return this.pages || (this.pages = {}), this.pages[t] ? (console.warn(
+      "Cannot register page with the same name. Please use a different name."
+    ), this) : (this.pages[t] = n, this);
+  }
+  withRoutes(t) {
+    return this._routes = t, this;
+  }
+}
+var as = /* @__PURE__ */ ((e) => (e.MISSING_MANIFEST = "MISSING_MANIFEST", e.MISSING_PLUGIN = "MISSING_PLUGIN", e.MISSING_ENTRYPOINT = "MISSING_ENTRYPOINT", e))(as || {});
+export {
+  J as ALL_SESSIONS_KEY,
+  Mn as BottomDrawerContext,
+  Ln as ConfirmationModalContext,
+  xe as ErrorTypes,
+  vs as ExtensionPointRegistry,
+  Qn as ExtensionPointStore,
+  bs as ExtensionProvider,
+  x as InformerResourceState,
+  Hn as InformerSyncPolicy,
+  to as Link,
+  Et as OperationsContext,
+  Ss as OperationsProvider,
+  $e as PluginContext,
+  gs as PluginContextProvider,
+  as as PluginErrorCode,
+  so as PluginWindow,
+  ro as PluginWindowRootProps,
+  $n as RightDrawerContext,
+  Ct as SettingsContext,
+  ws as SettingsProvider,
+  Ps as SnackbarProvider,
+  kn as actionToSnackbar,
+  Wn as connectionListQueryKey,
+  I as createErrorHandler,
+  Rn as defaultState,
+  wt as isCancelledError,
+  K as parseAppError,
+  X as showAppError,
+  Xs as useActiveSyncs,
+  At as useBottomDrawer,
+  qs as useConfirmationModal,
+  Ds as useConnection,
+  xs as useConnectionNamespaces,
+  Is as useConnectionStatus,
+  Fs as useConnections,
+  Js as useEditorSchemas,
+  Ts as useExec,
+  Ys as useExecuteAction,
+  Cs as useExtensionPoint,
+  Es as useExtensionPointComponents,
+  Pt as useExtensionRegistry,
+  Vs as useInformerState,
+  Ns as useLogs,
+  ks as useMetricProviders,
+  Jn as useMetricProvidersForResource,
+  Ms as useMetricStream,
+  is as useOperations,
+  Le as usePluginContext,
+  Os as usePluginData,
+  no as usePluginRouter,
+  _s as usePluginSettings,
+  $s as usePortForwardSessions,
+  P as useResolvedPluginId,
+  Gs as useResource,
+  Bs as useResourceActions,
+  Ks as useResourceAreaComponent,
+  Us as useResourceGroups,
+  Rs as useResourceMetrics,
+  Hs as useResourceMutations,
+  Ls as useResourcePortForwarder,
+  js as useResourceSearch,
+  Qs as useResourceType,
+  zs as useResourceTypes,
+  Ws as useResources,
+  As as useRightDrawer,
+  eo as useSettings,
+  $ as useSnackbar,
+  Zs as useStreamAction
+};