@qodalis/vue-cli 2.0.0-beta.1 → 2.0.0-beta.11

package/dist/index.js

@@ -0,0 +1,1284 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Cli: () => Cli,
+  CliConfigKey: () => CliConfigKey,
+  CliConfigProvider: () => CliConfigProvider,
+  CliEngine: () => import_cli3.CliEngine,
+  CliInjectionKey: () => CliInjectionKey,
+  CliPanel: () => CliPanel,
+  CliProvider: () => CliProvider,
+  useCli: () => useCli,
+  useCliEngine: () => useCliEngine
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/Cli.ts
+var import_vue2 = require("vue");
+var import_cli = require("@qodalis/cli");
+
+// src/cliInjection.ts
+var CliInjectionKey = /* @__PURE__ */ Symbol("qodalis-cli");
+
+// src/CliConfigProvider.ts
+var import_vue = require("vue");
+var CliConfigKey = /* @__PURE__ */ Symbol("qodalis-cli-config");
+var CliConfigProvider = (0, import_vue.defineComponent)({
+  name: "CliConfigProvider",
+  props: {
+    modules: {
+      type: Array,
+      default: void 0
+    },
+    processors: {
+      type: Array,
+      default: void 0
+    },
+    options: {
+      type: Object,
+      default: void 0
+    },
+    services: {
+      type: Object,
+      default: void 0
+    }
+  },
+  setup(props, { slots }) {
+    (0, import_vue.provide)(CliConfigKey, {
+      modules: props.modules,
+      processors: props.processors,
+      options: props.options,
+      services: props.services
+    });
+    return () => slots.default?.();
+  }
+});
+
+// src/Cli.ts
+var Cli = (0, import_vue2.defineComponent)({
+  name: "Cli",
+  props: {
+    modules: {
+      type: Array,
+      default: void 0
+    },
+    processors: {
+      type: Array,
+      default: void 0
+    },
+    options: {
+      type: Object,
+      default: void 0
+    },
+    services: {
+      type: Object,
+      default: void 0
+    },
+    snapshot: {
+      type: Object,
+      default: void 0
+    },
+    style: {
+      type: Object,
+      default: void 0
+    },
+    class: {
+      type: String,
+      default: void 0
+    }
+  },
+  emits: ["ready"],
+  setup(props, { emit }) {
+    const containerRef = (0, import_vue2.ref)(null);
+    const ctx = (0, import_vue2.inject)(CliInjectionKey, null);
+    const config = (0, import_vue2.inject)(CliConfigKey, null);
+    let engine = null;
+    if (ctx) {
+      return () => null;
+    }
+    const modules = props.modules ?? config?.modules;
+    const processors = props.processors ?? config?.processors;
+    const options = props.options ?? config?.options;
+    const services = props.services ?? config?.services;
+    (0, import_vue2.onMounted)(async () => {
+      if (!containerRef.value) return;
+      const engineOptions = props.snapshot ? { ...options, snapshot: props.snapshot } : options;
+      engine = new import_cli.CliEngine(containerRef.value, engineOptions);
+      engine.registerService("cli-framework", "Vue");
+      if (services) {
+        for (const [token, value] of Object.entries(services)) {
+          engine.registerService(token, value);
+        }
+      }
+      if (modules) {
+        engine.registerModules(modules);
+      }
+      if (processors) {
+        engine.registerProcessors(processors);
+      }
+      await engine.start();
+      emit("ready", engine);
+    });
+    (0, import_vue2.onBeforeUnmount)(() => {
+      engine?.destroy();
+      engine = null;
+    });
+    return () => (0, import_vue2.h)("div", {
+      ref: containerRef,
+      style: { height: "100%", ...props.style },
+      class: props.class
+    });
+  }
+});
+
+// src/CliPanel.ts
+var import_vue3 = require("vue");
+var import_cli_core = require("@qodalis/cli-core");
+var MIN_PANE_WIDTH_PERCENT = 10;
+function normalizePanes(panes) {
+  const total = panes.reduce((s, p) => s + p.widthPercent, 0);
+  if (total === 0) return;
+  const scale = 100 / total;
+  panes.forEach((p) => {
+    p.widthPercent *= scale;
+  });
+}
+var svgAttrs = {
+  width: "20",
+  height: "20",
+  viewBox: "0 0 24 24",
+  fill: "none",
+  stroke: "currentColor",
+  "stroke-width": "1.8",
+  "stroke-linecap": "round",
+  "stroke-linejoin": "round"
+};
+var terminalIcon = () => (0, import_vue3.h)("svg", { ...svgAttrs, width: "22", height: "22", "stroke-width": "2" }, [
+  (0, import_vue3.h)("polyline", { points: "4 17 10 11 4 5" }),
+  (0, import_vue3.h)("line", { x1: "12", y1: "19", x2: "20", y2: "19" })
+]);
+var maximizeIcon = () => (0, import_vue3.h)("svg", svgAttrs, [
+  (0, import_vue3.h)("polyline", { points: "15 3 21 3 21 9" }),
+  (0, import_vue3.h)("polyline", { points: "9 21 3 21 3 15" }),
+  (0, import_vue3.h)("line", { x1: "21", y1: "3", x2: "14", y2: "10" }),
+  (0, import_vue3.h)("line", { x1: "3", y1: "21", x2: "10", y2: "14" })
+]);
+var restoreIcon = () => (0, import_vue3.h)("svg", svgAttrs, [
+  (0, import_vue3.h)("polyline", { points: "4 14 10 14 10 20" }),
+  (0, import_vue3.h)("polyline", { points: "20 10 14 10 14 4" }),
+  (0, import_vue3.h)("line", { x1: "14", y1: "10", x2: "21", y2: "3" }),
+  (0, import_vue3.h)("line", { x1: "3", y1: "21", x2: "10", y2: "14" })
+]);
+var closeIcon = () => (0, import_vue3.h)("svg", svgAttrs, [
+  (0, import_vue3.h)("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+  (0, import_vue3.h)("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+]);
+var hideIcon = () => (0, import_vue3.h)("svg", svgAttrs, [
+  (0, import_vue3.h)("line", { x1: "5", y1: "18", x2: "19", y2: "18" }),
+  (0, import_vue3.h)("polyline", { points: "9 14 12 17 15 14" })
+]);
+function collapseChevron(position, isCollapsed) {
+  let points;
+  switch (position) {
+    case "top":
+      points = isCollapsed ? "6 9 12 15 18 9" : "18 15 12 9 6 15";
+      break;
+    case "left":
+      points = isCollapsed ? "9 18 15 12 9 6" : "15 6 9 12 15 18";
+      break;
+    case "right":
+      points = isCollapsed ? "15 6 9 12 15 18" : "9 18 15 12 9 6";
+      break;
+    default:
+      points = isCollapsed ? "18 15 12 9 6 15" : "6 9 12 15 18 9";
+      break;
+  }
+  return (0, import_vue3.h)("svg", svgAttrs, [(0, import_vue3.h)("polyline", { points })]);
+}
+function hideTabChevron(position) {
+  let points;
+  switch (position) {
+    case "top":
+      points = "6 9 12 15 18 9";
+      break;
+    case "left":
+      points = "9 18 15 12 9 6";
+      break;
+    case "right":
+      points = "15 6 9 12 15 18";
+      break;
+    default:
+      points = "18 15 12 9 6 15";
+      break;
+  }
+  return (0, import_vue3.h)("svg", { class: "cli-panel-hide-tab-arrow", ...svgAttrs, width: "14", height: "14", "stroke-width": "2.5" }, [
+    (0, import_vue3.h)("polyline", { points })
+  ]);
+}
+function positionIcon(pos, size = 20) {
+  let fillRect;
+  switch (pos) {
+    case "top":
+      fillRect = (0, import_vue3.h)("rect", { x: "4", y: "4", width: "16", height: "5", rx: "1", fill: "currentColor", stroke: "none", opacity: "0.5" });
+      break;
+    case "left":
+      fillRect = (0, import_vue3.h)("rect", { x: "4", y: "4", width: "5", height: "16", rx: "1", fill: "currentColor", stroke: "none", opacity: "0.5" });
+      break;
+    case "right":
+      fillRect = (0, import_vue3.h)("rect", { x: "15", y: "4", width: "5", height: "16", rx: "1", fill: "currentColor", stroke: "none", opacity: "0.5" });
+      break;
+    default:
+      fillRect = (0, import_vue3.h)("rect", { x: "4", y: "15", width: "16", height: "5", rx: "1", fill: "currentColor", stroke: "none", opacity: "0.5" });
+      break;
+  }
+  return (0, import_vue3.h)("svg", { ...svgAttrs, width: String(size), height: String(size) }, [
+    (0, import_vue3.h)("rect", { x: "3", y: "3", width: "18", height: "18", rx: "2" }),
+    fillRect
+  ]);
+}
+var CliPanel = (0, import_vue3.defineComponent)({
+  name: "CliPanel",
+  props: {
+    options: {
+      type: Object,
+      default: void 0
+    },
+    modules: { type: Array, default: void 0 },
+    processors: {
+      type: Array,
+      default: void 0
+    },
+    services: {
+      type: Object,
+      default: void 0
+    },
+    onClose: {
+      type: Function,
+      default: void 0
+    },
+    collapsed: { type: Boolean, default: void 0 },
+    hidden: { type: Boolean, default: void 0 },
+    maximized: { type: Boolean, default: void 0 },
+    activeTabId: { type: Number, default: void 0 },
+    position: { type: String, default: void 0 },
+    height: { type: Number, default: void 0 },
+    width: { type: Number, default: void 0 },
+    style: {
+      type: Object,
+      default: void 0
+    },
+    class: { type: String, default: void 0 }
+  },
+  emits: [
+    "update:collapsed",
+    "update:hidden",
+    "update:maximized",
+    "update:activeTabId",
+    "update:position",
+    "update:height",
+    "update:width",
+    "close",
+    "tab-added",
+    "tab-closed",
+    "pane-split",
+    "pane-closed"
+  ],
+  setup(props, { expose, emit }) {
+    const config = (0, import_vue3.inject)(CliConfigKey, null);
+    const mergedOptions = (0, import_vue3.computed)(() => props.options ?? config?.options);
+    const mergedModules = (0, import_vue3.computed)(() => props.modules ?? config?.modules);
+    const mergedProcessors = (0, import_vue3.computed)(() => props.processors ?? config?.processors);
+    const mergedServices = (0, import_vue3.computed)(() => props.services ?? config?.services);
+    const visible = (0, import_vue3.ref)(true);
+    const internalCollapsed = (0, import_vue3.ref)(mergedOptions.value?.isCollapsed ?? true);
+    const internalMaximized = (0, import_vue3.ref)(false);
+    const internalHeight = (0, import_vue3.ref)(600);
+    const internalWidth = (0, import_vue3.ref)(400);
+    const prevHeight = (0, import_vue3.ref)(600);
+    const prevWidth = (0, import_vue3.ref)(400);
+    const initialized = (0, import_vue3.ref)(false);
+    const internalHidden = (0, import_vue3.ref)(props.options?.isHidden ?? false);
+    let preHideCollapsed = true;
+    const internalActiveTabId = (0, import_vue3.ref)(0);
+    const internalPosition = (0, import_vue3.ref)(
+      (0, import_cli_core.loadPanelPosition)() ?? mergedOptions.value?.position ?? "bottom"
+    );
+    const resolvedCollapsed = (0, import_vue3.computed)(() => props.collapsed !== void 0 ? props.collapsed : internalCollapsed.value);
+    const resolvedHidden = (0, import_vue3.computed)(() => props.hidden !== void 0 ? props.hidden : internalHidden.value);
+    const resolvedMaximized = (0, import_vue3.computed)(() => props.maximized !== void 0 ? props.maximized : internalMaximized.value);
+    const resolvedActiveTabId = (0, import_vue3.computed)(() => props.activeTabId !== void 0 ? props.activeTabId : internalActiveTabId.value);
+    const resolvedHeight = (0, import_vue3.computed)(() => props.height !== void 0 ? props.height : internalHeight.value);
+    const resolvedWidth = (0, import_vue3.computed)(() => props.width !== void 0 ? props.width : internalWidth.value);
+    const resolvedPosition = (0, import_vue3.computed)(() => props.position !== void 0 ? props.position : internalPosition.value);
+    function updateCollapsed(value) {
+      internalCollapsed.value = value;
+      emit("update:collapsed", value);
+    }
+    function updateHidden(value) {
+      internalHidden.value = value;
+      emit("update:hidden", value);
+    }
+    function updateMaximized(value) {
+      internalMaximized.value = value;
+      emit("update:maximized", value);
+    }
+    function updateActiveTabId(value) {
+      internalActiveTabId.value = value;
+      emit("update:activeTabId", value);
+    }
+    function updateHeight(value) {
+      internalHeight.value = value;
+      emit("update:height", value);
+    }
+    function updateWidth(value) {
+      internalWidth.value = value;
+      emit("update:width", value);
+    }
+    function updatePosition(value) {
+      internalPosition.value = value;
+      (0, import_cli_core.savePanelPosition)(value);
+      emit("update:position", value);
+    }
+    const closable = (0, import_vue3.computed)(() => mergedOptions.value?.closable ?? true);
+    const resizable = (0, import_vue3.computed)(() => mergedOptions.value?.resizable ?? true);
+    const isHorizontal = (0, import_vue3.computed)(() => resolvedPosition.value === "left" || resolvedPosition.value === "right");
+    const hideable = (0, import_vue3.computed)(() => mergedOptions.value?.hideable ?? true);
+    const hideAlignment = (0, import_vue3.computed)(() => mergedOptions.value?.hideAlignment ?? "center");
+    const syncTheme = (0, import_vue3.computed)(() => mergedOptions.value?.syncTheme ?? false);
+    const themeStyles = (0, import_vue3.ref)({});
+    const tabs = (0, import_vue3.ref)([]);
+    const activePaneId = (0, import_vue3.ref)(0);
+    let nextTabId = 1;
+    let nextPaneId = 1;
+    const contextMenu = (0, import_vue3.ref)({
+      visible: false,
+      x: 0,
+      y: 0,
+      tabId: 0
+    });
+    const engineMap = /* @__PURE__ */ new Map();
+    const paneResizing = (0, import_vue3.ref)(false);
+    let paneResizeState = {
+      tabId: 0,
+      dividerIndex: 0,
+      startX: 0,
+      startWidths: [],
+      containerWidth: 0
+    };
+    const panelResizing = (0, import_vue3.ref)(false);
+    let panelResizeState = { startY: 0, startHeight: 0, startX: 0, startWidth: 0 };
+    function addTab(title) {
+      const tabId = nextTabId++;
+      const paneId = nextPaneId++;
+      tabs.value = [...tabs.value, {
+        id: tabId,
+        title: title ?? `Terminal ${tabId}`,
+        isEditing: false,
+        panes: [{ id: paneId, widthPercent: 100 }]
+      }];
+      updateActiveTabId(tabId);
+      activePaneId.value = paneId;
+      emit("tab-added", { tabId });
+      return tabId;
+    }
+    let themeObserver;
+    function syncThemeFromEngine() {
+      const engine = engineMap.values().next().value;
+      if (!engine) return;
+      const theme = engine.getTerminal().options.theme;
+      if (theme) themeStyles.value = (0, import_cli_core.derivePanelThemeStyles)(theme);
+    }
+    function setupThemeSync() {
+      if (!syncTheme.value) return;
+      setTimeout(() => {
+        syncThemeFromEngine();
+        const container = document.querySelector(".cli-panel-wrapper .terminal-container");
+        if (!container) return;
+        themeObserver?.disconnect();
+        themeObserver = new MutationObserver(syncThemeFromEngine);
+        themeObserver.observe(container, { attributes: true, attributeFilter: ["style"] });
+      }, 200);
+    }
+    (0, import_vue3.onMounted)(() => {
+      document.addEventListener("click", closePositionDropdown);
+    });
+    (0, import_vue3.onBeforeUnmount)(() => {
+      themeObserver?.disconnect();
+      document.removeEventListener("click", closePositionDropdown);
+    });
+    function toggle() {
+      const newVal = !resolvedCollapsed.value;
+      updateCollapsed(newVal);
+      if (!newVal && !initialized.value) {
+        initialized.value = true;
+        addTab();
+        setupThemeSync();
+      }
+    }
+    function closeTab(id) {
+      const idx = tabs.value.findIndex((t) => t.id === id);
+      if (idx === -1) return;
+      tabs.value.splice(idx, 1);
+      emit("tab-closed", { tabId: id });
+      if (tabs.value.length === 0) {
+        initialized.value = false;
+        updateCollapsed(true);
+        return;
+      }
+      if (resolvedActiveTabId.value === id) {
+        const newIdx = Math.min(idx, tabs.value.length - 1);
+        selectTab(tabs.value[newIdx].id);
+      }
+    }
+    function selectTab(id) {
+      updateActiveTabId(id);
+      const tab = tabs.value.find((t) => t.id === id);
+      if (tab && tab.panes.length > 0) {
+        activePaneId.value = tab.panes[0].id;
+      }
+    }
+    function splitPane(tabId) {
+      const targetTabId = tabId ?? resolvedActiveTabId.value;
+      const paneId = nextPaneId++;
+      tabs.value = tabs.value.map((t) => {
+        if (t.id !== targetTabId) return t;
+        const newPanes = [...t.panes, { id: paneId, widthPercent: 0 }];
+        normalizePanes(newPanes);
+        return { ...t, panes: newPanes };
+      });
+      activePaneId.value = paneId;
+      emit("pane-split", { paneId, tabId: targetTabId });
+      return paneId;
+    }
+    function closePane(paneId) {
+      for (const tab of tabs.value) {
+        const idx = tab.panes.findIndex((p) => p.id === paneId);
+        if (idx === -1) continue;
+        if (tab.panes.length <= 1) {
+          closeTab(tab.id);
+          return;
+        }
+        engineMap.get(paneId)?.destroy();
+        engineMap.delete(paneId);
+        const newPanes = tab.panes.filter((p) => p.id !== paneId);
+        normalizePanes(newPanes);
+        if (activePaneId.value === paneId) {
+          activePaneId.value = newPanes[Math.min(idx, newPanes.length - 1)].id;
+        }
+        emit("pane-closed", { paneId });
+        tabs.value = tabs.value.map(
+          (t) => t.id === tab.id ? { ...t, panes: newPanes } : t
+        );
+        return;
+      }
+    }
+    function renameTab(tabId, title) {
+      tabs.value = tabs.value.map((t) => t.id === tabId ? { ...t, title } : t);
+    }
+    function startRename(tabId) {
+      tabs.value.forEach((t) => {
+        t.isEditing = t.id === tabId;
+      });
+    }
+    function commitRename(tabId, value) {
+      const trimmed = value.trim();
+      const tab = tabs.value.find((t) => t.id === tabId);
+      if (tab) {
+        if (trimmed) tab.title = trimmed;
+        tab.isEditing = false;
+      }
+    }
+    function closeContextMenu() {
+      contextMenu.value = { ...contextMenu.value, visible: false };
+    }
+    function onDocClick() {
+      if (contextMenu.value.visible) closeContextMenu();
+    }
+    (0, import_vue3.onMounted)(() => document.addEventListener("click", onDocClick));
+    (0, import_vue3.onBeforeUnmount)(
+      () => document.removeEventListener("click", onDocClick)
+    );
+    function onPanelResizeStart(e) {
+      if (!resizable.value) return;
+      e.preventDefault();
+      if (resolvedCollapsed.value) toggle();
+      panelResizing.value = true;
+      panelResizeState = {
+        startY: e.clientY,
+        startHeight: resolvedHeight.value,
+        startX: e.clientX,
+        startWidth: resolvedWidth.value
+      };
+    }
+    function onPanelResizeMove(e) {
+      if (!panelResizing.value) return;
+      if (isHorizontal.value) {
+        const deltaX = resolvedPosition.value === "left" ? e.clientX - panelResizeState.startX : panelResizeState.startX - e.clientX;
+        let next = Math.max(100, panelResizeState.startWidth + deltaX);
+        if (next > window.innerWidth) next = window.innerWidth;
+        updateWidth(next);
+      } else {
+        const deltaY = resolvedPosition.value === "top" ? e.clientY - panelResizeState.startY : panelResizeState.startY - e.clientY;
+        let next = Math.max(100, panelResizeState.startHeight + deltaY);
+        if (next > window.innerHeight) next = window.innerHeight;
+        updateHeight(next);
+      }
+    }
+    function onPanelResizeEnd() {
+      panelResizing.value = false;
+    }
+    (0, import_vue3.onMounted)(() => {
+      document.addEventListener("mousemove", onPanelResizeMove);
+      document.addEventListener("mouseup", onPanelResizeEnd);
+    });
+    (0, import_vue3.onBeforeUnmount)(() => {
+      document.removeEventListener("mousemove", onPanelResizeMove);
+      document.removeEventListener("mouseup", onPanelResizeEnd);
+    });
+    function onPaneResizeStart(e, tabId, dividerIndex) {
+      e.preventDefault();
+      const tab = tabs.value.find((t) => t.id === tabId);
+      if (!tab) return;
+      paneResizing.value = true;
+      const container = e.target.closest(
+        ".cli-panel-panes-container"
+      );
+      paneResizeState = {
+        tabId,
+        dividerIndex,
+        startX: e.clientX,
+        startWidths: tab.panes.map((p) => p.widthPercent),
+        containerWidth: container ? container.clientWidth : 1
+      };
+      document.body.classList.add("cli-pane-resizing");
+    }
+    function onPaneResizeMove(e) {
+      if (!paneResizing.value) return;
+      const s = paneResizeState;
+      const deltaPct = (e.clientX - s.startX) / s.containerWidth * 100;
+      const i = s.dividerIndex;
+      let leftW = s.startWidths[i] + deltaPct;
+      let rightW = s.startWidths[i + 1] - deltaPct;
+      if (leftW < MIN_PANE_WIDTH_PERCENT) {
+        leftW = MIN_PANE_WIDTH_PERCENT;
+        rightW = s.startWidths[i] + s.startWidths[i + 1] - MIN_PANE_WIDTH_PERCENT;
+      }
+      if (rightW < MIN_PANE_WIDTH_PERCENT) {
+        rightW = MIN_PANE_WIDTH_PERCENT;
+        leftW = s.startWidths[i] + s.startWidths[i + 1] - MIN_PANE_WIDTH_PERCENT;
+      }
+      const tab = tabs.value.find((t) => t.id === s.tabId);
+      if (tab) {
+        tab.panes[i].widthPercent = leftW;
+        tab.panes[i + 1].widthPercent = rightW;
+      }
+    }
+    function onPaneResizeEnd() {
+      if (!paneResizing.value) return;
+      paneResizing.value = false;
+      document.body.classList.remove("cli-pane-resizing");
+    }
+    (0, import_vue3.onMounted)(() => {
+      document.addEventListener("mousemove", onPaneResizeMove);
+      document.addEventListener("mouseup", onPaneResizeEnd);
+    });
+    (0, import_vue3.onBeforeUnmount)(() => {
+      document.removeEventListener("mousemove", onPaneResizeMove);
+      document.removeEventListener("mouseup", onPaneResizeEnd);
+    });
+    function toggleMaximize() {
+      if (!resolvedMaximized.value) {
+        if (isHorizontal.value) {
+          prevWidth.value = resolvedWidth.value;
+          updateWidth(window.innerWidth);
+        } else {
+          prevHeight.value = resolvedHeight.value;
+          updateHeight(window.innerHeight);
+        }
+      } else {
+        if (isHorizontal.value) {
+          updateWidth(prevWidth.value);
+        } else {
+          updateHeight(prevHeight.value);
+        }
+      }
+      updateMaximized(!resolvedMaximized.value);
+    }
+    function handleClose() {
+      visible.value = false;
+      emit("close");
+      props.onClose?.();
+    }
+    function handleHide() {
+      preHideCollapsed = resolvedCollapsed.value;
+      updateHidden(true);
+    }
+    function handleUnhide() {
+      updateHidden(false);
+      updateCollapsed(preHideCollapsed);
+    }
+    const positionDropdownOpen = (0, import_vue3.ref)(false);
+    function closePositionDropdown() {
+      positionDropdownOpen.value = false;
+    }
+    function togglePositionDropdown(e) {
+      e.stopPropagation();
+      positionDropdownOpen.value = !positionDropdownOpen.value;
+    }
+    function selectPosition(pos) {
+      positionDropdownOpen.value = false;
+      updatePosition(pos);
+    }
+    function getEngine(paneId) {
+      const targetId = paneId ?? activePaneId.value;
+      return engineMap.get(targetId);
+    }
+    function getState() {
+      return {
+        collapsed: resolvedCollapsed.value,
+        hidden: resolvedHidden.value,
+        maximized: resolvedMaximized.value,
+        position: resolvedPosition.value,
+        height: resolvedHeight.value,
+        width: resolvedWidth.value,
+        activeTabId: resolvedActiveTabId.value,
+        activePaneId: activePaneId.value,
+        tabs: tabs.value.map((t) => ({
+          id: t.id,
+          title: t.title,
+          panes: t.panes.map((p) => ({ id: p.id, widthPercent: p.widthPercent }))
+        }))
+      };
+    }
+    expose({
+      open: () => {
+        if (!visible.value) {
+          visible.value = true;
+        }
+        if (resolvedHidden.value) {
+          updateHidden(false);
+        }
+        if (resolvedCollapsed.value) {
+          updateCollapsed(false);
+          if (!initialized.value) {
+            initialized.value = true;
+            addTab();
+            setupThemeSync();
+          }
+        }
+      },
+      collapse: () => {
+        if (!resolvedCollapsed.value) updateCollapsed(true);
+      },
+      toggleCollapse: () => {
+        if (resolvedCollapsed.value) {
+          updateCollapsed(false);
+          if (!initialized.value) {
+            initialized.value = true;
+            addTab();
+            setupThemeSync();
+          }
+        } else {
+          updateCollapsed(true);
+        }
+      },
+      hide: () => {
+        if (!resolvedHidden.value) updateHidden(true);
+      },
+      unhide: () => {
+        if (resolvedHidden.value) updateHidden(false);
+      },
+      toggleHide: () => {
+        updateHidden(!resolvedHidden.value);
+      },
+      close: handleClose,
+      maximize: () => {
+        if (!resolvedMaximized.value) updateMaximized(true);
+      },
+      restore: () => {
+        if (resolvedMaximized.value) updateMaximized(false);
+      },
+      toggleMaximize: () => {
+        updateMaximized(!resolvedMaximized.value);
+      },
+      resize: (dims) => {
+        if (dims.height !== void 0) updateHeight(dims.height);
+        if (dims.width !== void 0) updateWidth(dims.width);
+      },
+      setPosition: updatePosition,
+      addTab,
+      closeTab,
+      selectTab,
+      renameTab,
+      splitPane,
+      closePane,
+      getEngine,
+      getState
+    });
+    return () => {
+      if (!visible.value) return null;
+      const wrapperClass = [
+        "cli-panel-wrapper",
+        resolvedCollapsed.value && "collapsed",
+        resolvedMaximized.value && "maximized",
+        panelResizing.value && "resizing",
+        props.class
+      ].filter(Boolean).join(" ");
+      const wrapperStyle = {
+        ...isHorizontal.value ? { width: `${resolvedWidth.value}px` } : { height: `${resolvedHeight.value}px` },
+        ...resolvedHidden.value ? { display: "none" } : {},
+        ...themeStyles.value,
+        ...props.style
+      };
+      const headerEl = (0, import_vue3.h)("div", { class: "cli-panel-header" }, [
+        (0, import_vue3.h)(
+          "div",
+          {
+            class: "cli-panel-resize-bar",
+            onMousedown: onPanelResizeStart
+          },
+          [(0, import_vue3.h)("div", { class: "cli-panel-resize-grip" })]
+        ),
+        (0, import_vue3.h)("div", { class: "cli-panel-header-content" }, [
+          (0, import_vue3.h)("p", { class: "cli-panel-title" }, [
+            (0, import_vue3.h)("span", { class: "cli-panel-title-icon" }, [
+              terminalIcon()
+            ]),
+            "CLI"
+          ]),
+          (0, import_vue3.h)("div", { class: "cli-panel-action-buttons" }, [
+            (0, import_vue3.h)("div", {
+              class: "cli-panel-btn-position-wrapper",
+              onClick: (e) => e.stopPropagation()
+            }, [
+              (0, import_vue3.h)("button", {
+                class: "cli-panel-btn cli-panel-btn-position",
+                title: "Move panel",
+                onClick: togglePositionDropdown
+              }, [positionIcon(resolvedPosition.value)]),
+              positionDropdownOpen.value ? (0, import_vue3.h)(
+                "div",
+                { class: "cli-panel-position-dropdown" },
+                ["bottom", "top", "left", "right"].map(
+                  (pos) => (0, import_vue3.h)("button", {
+                    class: ["cli-panel-position-dropdown-item", resolvedPosition.value === pos ? "active" : ""].filter(Boolean).join(" "),
+                    onClick: () => selectPosition(pos)
+                  }, [
+                    positionIcon(pos, 16),
+                    pos.charAt(0).toUpperCase() + pos.slice(1)
+                  ])
+                )
+              ) : null
+            ]),
+            hideable.value ? (0, import_vue3.h)("button", {
+              class: "cli-panel-btn cli-panel-btn-hide",
+              title: "Hide",
+              onClick: handleHide
+            }, [hideIcon()]) : null,
+            (0, import_vue3.h)(
+              "button",
+              {
+                class: "cli-panel-btn",
+                title: resolvedMaximized.value ? "Restore" : "Maximize",
+                disabled: resolvedCollapsed.value,
+                onClick: toggleMaximize
+              },
+              [resolvedMaximized.value ? restoreIcon() : maximizeIcon()]
+            ),
+            (0, import_vue3.h)(
+              "button",
+              {
+                class: "cli-panel-btn",
+                title: resolvedCollapsed.value ? "Expand" : "Collapse",
+                onClick: toggle
+              },
+              [collapseChevron(resolvedPosition.value, resolvedCollapsed.value)]
+            ),
+            closable.value ? (0, import_vue3.h)(
+              "button",
+              {
+                class: "cli-panel-btn cli-panel-btn-close",
+                title: "Close",
+                onClick: handleClose
+              },
+              [closeIcon()]
+            ) : null
+          ])
+        ])
+      ]);
+      const contentEl = initialized.value ? (0, import_vue3.h)("div", { class: "cli-panel-content", style: resolvedCollapsed.value ? { display: "none" } : void 0 }, [
+        // Tab bar
+        (0, import_vue3.h)("div", { class: "cli-panel-tabs" }, [
+          (0, import_vue3.h)(
+            "ul",
+            { class: "cli-panel-tab-list" },
+            tabs.value.map(
+              (tab) => (0, import_vue3.h)(
+                "li",
+                {
+                  key: tab.id,
+                  class: [
+                    "cli-panel-tab",
+                    tab.id === resolvedActiveTabId.value && "active"
+                  ].filter(Boolean).join(" "),
+                  onClick: () => selectTab(tab.id),
+                  onDblclick: () => startRename(tab.id),
+                  onContextmenu: (e) => {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    contextMenu.value = {
+                      visible: true,
+                      x: e.clientX,
+                      y: e.clientY,
+                      tabId: tab.id
+                    };
+                  }
+                },
+                tab.isEditing ? [
+                  (0, import_vue3.h)("input", {
+                    class: "cli-panel-tab-rename-input",
+                    type: "text",
+                    value: tab.title,
+                    onKeydown: (e) => {
+                      if (e.key === "Enter")
+                        commitRename(
+                          tab.id,
+                          e.target.value
+                        );
+                      else if (e.key === "Escape") {
+                        tab.isEditing = false;
+                      }
+                    },
+                    onBlur: (e) => commitRename(
+                      tab.id,
+                      e.target.value
+                    ),
+                    onClick: (e) => e.stopPropagation(),
+                    onDblclick: (e) => e.stopPropagation()
+                  })
+                ] : [
+                  (0, import_vue3.h)(
+                    "span",
+                    {
+                      class: "cli-panel-tab-title"
+                    },
+                    tab.title
+                  ),
+                  (0, import_vue3.h)(
+                    "button",
+                    {
+                      class: "cli-panel-tab-close-btn",
+                      title: "Close tab",
+                      onClick: (e) => {
+                        e.stopPropagation();
+                        closeTab(
+                          tab.id
+                        );
+                      }
+                    },
+                    "\xD7"
+                  )
+                ]
+              )
+            )
+          ),
+          (0, import_vue3.h)(
+            "button",
+            {
+              class: "cli-panel-add-tab",
+              title: "New terminal",
+              onClick: addTab
+            },
+            "+"
+          )
+        ]),
+        // Terminal instances
+        (0, import_vue3.h)(
+          "div",
+          { class: "cli-panel-instances" },
+          tabs.value.map(
+            (tab) => (0, import_vue3.h)(
+              "div",
+              {
+                key: tab.id,
+                class: "cli-panel-instance",
+                style: {
+                  display: tab.id === resolvedActiveTabId.value ? void 0 : "none"
+                }
+              },
+              [
+                (0, import_vue3.h)(
+                  "div",
+                  {
+                    class: [
+                      "cli-panel-panes-container",
+                      paneResizing.value && "resizing"
+                    ].filter(Boolean).join(" ")
+                  },
+                  tab.panes.flatMap((pane, i) => {
+                    const nodes = [];
+                    if (i > 0) {
+                      nodes.push(
+                        (0, import_vue3.h)(
+                          "div",
+                          {
+                            class: "cli-panel-pane-divider",
+                            onMousedown: (e) => onPaneResizeStart(
+                              e,
+                              tab.id,
+                              i - 1
+                            )
+                          },
+                          [
+                            (0, import_vue3.h)("div", {
+                              class: "cli-panel-pane-divider-grip"
+                            })
+                          ]
+                        )
+                      );
+                    }
+                    nodes.push(
+                      (0, import_vue3.h)(
+                        "div",
+                        {
+                          class: [
+                            "cli-panel-pane",
+                            pane.id === activePaneId.value && tab.id === resolvedActiveTabId.value && "active-pane"
+                          ].filter(
+                            Boolean
+                          ).join(" "),
+                          style: {
+                            flex: `${pane.widthPercent} 1 0`
+                          },
+                          onClick: () => {
+                            activePaneId.value = pane.id;
+                            updateActiveTabId(tab.id);
+                          }
+                        },
+                        [
+                          tab.panes.length > 1 ? (0, import_vue3.h)(
+                            "button",
+                            {
+                              class: "cli-panel-pane-close-btn",
+                              title: "Close pane",
+                              onClick: (e) => {
+                                e.stopPropagation();
+                                closePane(
+                                  pane.id
+                                );
+                              }
+                            },
+                            "\xD7"
+                          ) : null,
+                          (0, import_vue3.h)(Cli, {
+                            options: mergedOptions.value,
+                            modules: mergedModules.value,
+                            processors: mergedProcessors.value,
+                            services: mergedServices.value,
+                            snapshot: pane.snapshot,
+                            style: {
+                              height: "100%"
+                            },
+                            onReady: (engine) => {
+                              engineMap.set(pane.id, engine);
+                            }
+                          })
+                        ]
+                      )
+                    );
+                    return nodes;
+                  })
+                )
+              ]
+            )
+          )
+        )
+      ]) : null;
+      const contextMenuEl = contextMenu.value.visible ? (0, import_vue3.h)(
+        "div",
+        {
+          class: "cli-panel-context-menu",
+          style: {
+            left: `${contextMenu.value.x}px`,
+            top: `${contextMenu.value.y}px`
+          },
+          onClick: (e) => e.stopPropagation()
+        },
+        [
+          (0, import_vue3.h)(
+            "button",
+            {
+              class: "cli-panel-context-menu-item",
+              onClick: () => {
+                closeContextMenu();
+                startRename(contextMenu.value.tabId);
+              }
+            },
+            "Rename"
+          ),
+          (0, import_vue3.h)(
+            "button",
+            {
+              class: "cli-panel-context-menu-item",
+              onClick: () => {
+                const tab = tabs.value.find(
+                  (t) => t.id === contextMenu.value.tabId
+                );
+                closeContextMenu();
+                if (!tab) return;
+                const sourceEngine = engineMap.get(tab.panes[0]?.id);
+                const snapshot = sourceEngine?.snapshot();
+                const paneId = nextPaneId++;
+                const tabId = nextTabId++;
+                const idx = tabs.value.indexOf(tab);
+                tabs.value.splice(idx + 1, 0, {
+                  id: tabId,
+                  title: `${tab.title} (copy)`,
+                  isEditing: false,
+                  panes: [
+                    { id: paneId, widthPercent: 100, snapshot }
+                  ]
+                });
+                updateActiveTabId(tabId);
+                activePaneId.value = paneId;
+              }
+            },
+            "Duplicate"
+          ),
+          (0, import_vue3.h)(
+            "button",
+            {
+              class: "cli-panel-context-menu-item",
+              onClick: () => {
+                closeContextMenu();
+                splitPane(contextMenu.value.tabId);
+              }
+            },
+            "Split Right"
+          ),
+          (0, import_vue3.h)("div", {
+            class: "cli-panel-context-menu-separator"
+          }),
+          (0, import_vue3.h)(
+            "button",
+            {
+              class: "cli-panel-context-menu-item",
+              onClick: () => {
+                closeContextMenu();
+                closeTab(contextMenu.value.tabId);
+              }
+            },
+            "Close"
+          ),
+          (0, import_vue3.h)(
+            "button",
+            {
+              class: "cli-panel-context-menu-item",
+              disabled: tabs.value.length <= 1,
+              onClick: () => {
+                const id = contextMenu.value.tabId;
+                closeContextMenu();
+                tabs.value = tabs.value.filter(
+                  (t) => t.id === id
+                );
+                updateActiveTabId(id);
+              }
+            },
+            "Close Others"
+          ),
+          (0, import_vue3.h)(
+            "button",
+            {
+              class: "cli-panel-context-menu-item",
+              onClick: () => {
+                const id = contextMenu.value.tabId;
+                closeContextMenu();
+                const idx = tabs.value.findIndex(
+                  (t) => t.id === id
+                );
+                if (idx !== -1)
+                  tabs.value = tabs.value.slice(
+                    0,
+                    idx + 1
+                  );
+              }
+            },
+            "Close to the Right"
+          ),
+          (0, import_vue3.h)("div", {
+            class: "cli-panel-context-menu-separator"
+          }),
+          (0, import_vue3.h)(
+            "button",
+            {
+              class: "cli-panel-context-menu-item destructive",
+              onClick: () => {
+                closeContextMenu();
+                tabs.value = [];
+                initialized.value = false;
+                updateCollapsed(true);
+              }
+            },
+            "Close All"
+          )
+        ]
+      ) : null;
+      const hideTabEl = resolvedHidden.value ? (0, import_vue3.h)("button", {
+        class: "cli-panel-hide-tab",
+        "data-position": resolvedPosition.value,
+        "data-hide-align": hideAlignment.value,
+        style: themeStyles.value,
+        title: "Show CLI",
+        onClick: handleUnhide
+      }, [
+        (0, import_vue3.h)("svg", { class: "cli-panel-hide-tab-icon", ...svgAttrs, width: "16", height: "16", "stroke-width": "2" }, [
+          (0, import_vue3.h)("polyline", { points: "4 17 10 11 4 5" }),
+          (0, import_vue3.h)("line", { x1: "12", y1: "19", x2: "20", y2: "19" })
+        ]),
+        (0, import_vue3.h)("span", { class: "cli-panel-hide-tab-label" }, "CLI"),
+        hideTabChevron(resolvedPosition.value)
+      ]) : null;
+      return (0, import_vue3.h)("div", {}, [
+        hideTabEl,
+        (0, import_vue3.h)(
+          "div",
+          {
+            class: wrapperClass,
+            style: wrapperStyle,
+            "data-position": resolvedPosition.value,
+            "data-resizable": String(resizable.value),
+            "data-closable": String(closable.value),
+            "data-hideable": String(hideable.value)
+          },
+          [headerEl, contentEl]
+        ),
+        contextMenuEl
+      ]);
+    };
+  }
+});
+
+// src/CliProvider.ts
+var import_vue5 = require("vue");
+
+// src/useCliEngine.ts
+var import_vue4 = require("vue");
+var import_cli2 = require("@qodalis/cli");
+function useCliEngine(containerRef, config) {
+  const engine = (0, import_vue4.shallowRef)(null);
+  (0, import_vue4.onMounted)(async () => {
+    if (!containerRef.value) return;
+    const e = new import_cli2.CliEngine(containerRef.value, config?.options);
+    e.registerService("cli-framework", "Vue");
+    if (config?.services) {
+      for (const [token, value] of Object.entries(config.services)) {
+        e.registerService(token, value);
+      }
+    }
+    if (config?.modules) {
+      e.registerModules(config.modules);
+    }
+    if (config?.processors) {
+      e.registerProcessors(config.processors);
+    }
+    await e.start();
+    engine.value = e;
+  });
+  (0, import_vue4.onBeforeUnmount)(() => {
+    engine.value?.destroy();
+    engine.value = null;
+  });
+  return engine;
+}
+
+// src/CliProvider.ts
+var CliProvider = (0, import_vue5.defineComponent)({
+  name: "CliProvider",
+  props: {
+    modules: {
+      type: Array,
+      default: void 0
+    },
+    processors: {
+      type: Array,
+      default: void 0
+    },
+    options: {
+      type: Object,
+      default: void 0
+    },
+    services: {
+      type: Object,
+      default: void 0
+    },
+    style: {
+      type: Object,
+      default: void 0
+    }
+  },
+  emits: ["ready"],
+  setup(props, { slots, emit }) {
+    const containerRef = (0, import_vue5.ref)(null);
+    const engine = useCliEngine(containerRef, {
+      modules: props.modules,
+      processors: props.processors,
+      options: props.options,
+      services: props.services
+    });
+    (0, import_vue5.provide)(CliInjectionKey, { engine });
+    return () => (0, import_vue5.h)("div", { style: { height: "100%" } }, [
+      (0, import_vue5.h)("div", {
+        ref: containerRef,
+        style: { height: "100%", ...props.style }
+      }),
+      slots.default?.()
+    ]);
+  }
+});
+
+// src/useCli.ts
+var import_vue6 = require("vue");
+function useCli() {
+  const ctx = (0, import_vue6.inject)(CliInjectionKey);
+  if (!ctx) {
+    throw new Error(
+      "useCli() must be used inside a <CliProvider> component"
+    );
+  }
+  return ctx;
+}
+
+// src/index.ts
+var import_cli3 = require("@qodalis/cli");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cli,
+  CliConfigKey,
+  CliConfigProvider,
+  CliEngine,
+  CliInjectionKey,
+  CliPanel,
+  CliProvider,
+  useCli,
+  useCliEngine
+});
+//# sourceMappingURL=index.js.map