@qodalis/vue-cli 2.0.0-beta.2 → 2.0.0-beta.20

package/dist/index.js

@@ -0,0 +1,653 @@
+"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_cli4.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 hostConfig = (0, import_cli.resolveCliHostConfig)(props, config);
+    (0, import_vue2.onMounted)(async () => {
+      if (!containerRef.value) return;
+      engine = (0, import_cli.createCliEngine)(containerRef.value, { ...hostConfig, snapshot: props.snapshot, framework: "Vue" });
+      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_cli2 = require("@qodalis/cli");
+var PANEL_REF_METHODS = [
+  "open",
+  "collapse",
+  "toggleCollapse",
+  "hide",
+  "unhide",
+  "toggleHide",
+  "close",
+  "maximize",
+  "restore",
+  "toggleMaximize",
+  "resize",
+  "setPosition",
+  "addTab",
+  "closeTab",
+  "selectTab",
+  "renameTab",
+  "splitPane",
+  "closePane",
+  "getEngine",
+  "getState"
+];
+function icon(svg, className) {
+  return (0, import_vue3.h)("svg", { class: className, ...(0, import_cli2.svgAttrs)(svg) }, svg.shapes.map((shape) => (0, import_vue3.h)(shape.tag, shape.attrs)));
+}
+var stop = (e) => e.stopPropagation();
+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)(() => (0, import_cli2.mergeCliOptions)(props.options, config?.options));
+    const hostConfig = (0, import_vue3.computed)(() => (0, import_cli2.resolveCliHostConfig)(props, config));
+    const controlled = () => ({
+      collapsed: props.collapsed,
+      hidden: props.hidden,
+      maximized: props.maximized,
+      activeTabId: props.activeTabId,
+      position: props.position,
+      height: props.height,
+      width: props.width
+    });
+    const controller = new import_cli2.CliPanelController({
+      config: mergedOptions.value,
+      controlled: controlled(),
+      callbacks: {
+        onCollapsedChange: (v) => emit("update:collapsed", v),
+        onHiddenChange: (v) => emit("update:hidden", v),
+        onMaximizedChange: (v) => emit("update:maximized", v),
+        onActiveTabIdChange: (v) => emit("update:activeTabId", v),
+        onPositionChange: (v) => emit("update:position", v),
+        onHeightChange: (v) => emit("update:height", v),
+        onWidthChange: (v) => emit("update:width", v),
+        onClose: () => {
+          emit("close");
+          props.onClose?.();
+        },
+        onTabAdded: (e) => emit("tab-added", e),
+        onTabClosed: (e) => emit("tab-closed", e),
+        onPaneSplit: (e) => emit("pane-split", e),
+        onPaneClosed: (e) => emit("pane-closed", e)
+      }
+    });
+    const state = (0, import_vue3.shallowRef)(controller.getSnapshot());
+    const unsubscribe = controller.subscribe(() => {
+      state.value = controller.getSnapshot();
+    });
+    (0, import_vue3.watch)(controlled, (values) => controller.setControlled(values));
+    (0, import_vue3.watch)(mergedOptions, (options) => controller.setOptions(options));
+    const root = (0, import_vue3.shallowRef)(null);
+    (0, import_vue3.onMounted)(() => controller.setRootElement(root.value));
+    (0, import_vue3.onBeforeUnmount)(() => {
+      unsubscribe();
+      controller.destroy();
+    });
+    const exposed = {};
+    for (const method of PANEL_REF_METHODS) {
+      exposed[method] = controller[method].bind(controller);
+    }
+    expose(exposed);
+    const openDropdown = (e, dropdown) => {
+      if (!dropdown) return;
+      e.stopPropagation();
+      const anchor = e.currentTarget;
+      if (dropdown === "services") controller.toggleServicesDropdown(anchor);
+      else controller.toggleServersDropdown(anchor);
+    };
+    const renderHeader = (s) => {
+      const indicators = (0, import_cli2.statusIndicators)(s);
+      return (0, import_vue3.h)("div", { class: "cli-panel-header" }, [
+        (0, import_vue3.h)(
+          "div",
+          {
+            class: "cli-panel-resize-bar",
+            onMousedown: (e) => {
+              if (!s.resizable) return;
+              e.preventDefault();
+              controller.startPanelResize(e.clientX, e.clientY);
+            }
+          },
+          [(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" }, [icon(import_cli2.TERMINAL_ICON)]), import_cli2.PANEL_LABELS.title]),
+          s.showStatusIndicators ? (0, import_vue3.h)(
+            "div",
+            { class: "cli-panel-status-indicators" },
+            indicators.map(
+              (item) => (0, import_vue3.h)(
+                "span",
+                {
+                  key: item.key,
+                  class: (0, import_cli2.joinClasses)("cli-panel-status-item", item.itemClass),
+                  onClick: item.dropdown ? (e) => openDropdown(e, item.dropdown) : void 0
+                },
+                [
+                  item.dotClass ? (0, import_vue3.h)("span", { class: `cli-panel-status-dot ${item.dotClass}` }) : null,
+                  item.icon ? (0, import_vue3.h)("span", { class: (0, import_cli2.joinClasses)("cli-panel-status-icon", item.iconClass) }, item.icon) : null,
+                  (0, import_vue3.h)("span", { class: "cli-panel-status-label" }, item.label)
+                ]
+              )
+            )
+          ) : null,
+          // Compact indicators for left/right positions (CSS controls visibility).
+          (0, import_vue3.h)(
+            "div",
+            { class: "cli-panel-status-indicators-compact" },
+            indicators.map(
+              (item) => (0, import_vue3.h)(
+                "span",
+                {
+                  key: item.key,
+                  class: (0, import_cli2.joinClasses)("cli-panel-status-compact-item", item.compactClass),
+                  title: item.title,
+                  onClick: item.dropdown ? (e) => openDropdown(e, item.dropdown) : void 0
+                },
+                [
+                  item.compactDotClass ? (0, import_vue3.h)("span", { class: item.compactDotClass }) : null,
+                  item.dotClass ? (0, import_vue3.h)("span", { class: `cli-panel-status-dot ${item.dotClass}` }) : null,
+                  item.icon ? (0, import_vue3.h)("span", { class: (0, import_cli2.joinClasses)("cli-panel-status-icon", item.iconClass) }, item.icon) : null
+                ]
+              )
+            )
+          ),
+          (0, import_vue3.h)("div", { class: "cli-panel-action-buttons" }, [
+            (0, import_vue3.h)("div", { class: "cli-panel-btn-position-wrapper", onClick: stop }, [
+              (0, import_vue3.h)(
+                "button",
+                {
+                  class: "cli-panel-btn cli-panel-btn-position",
+                  title: import_cli2.PANEL_LABELS.movePanel,
+                  onClick: () => controller.togglePositionDropdown()
+                },
+                [icon((0, import_cli2.positionIcon)(s.position))]
+              ),
+              s.positionDropdownOpen ? (0, import_vue3.h)(
+                "div",
+                { class: "cli-panel-position-dropdown" },
+                (0, import_cli2.positionOptions)(s).map(
+                  (opt) => (0, import_vue3.h)(
+                    "button",
+                    { key: opt.position, class: opt.className, onClick: () => controller.setPosition(opt.position) },
+                    [icon((0, import_cli2.positionIcon)(opt.position, 16)), opt.label]
+                  )
+                )
+              ) : null
+            ]),
+            s.hideable ? (0, import_vue3.h)("button", { class: "cli-panel-btn cli-panel-btn-hide", title: import_cli2.PANEL_LABELS.hide, onClick: () => controller.hide() }, [icon(import_cli2.HIDE_ICON)]) : null,
+            (0, import_vue3.h)(
+              "button",
+              {
+                class: "cli-panel-btn",
+                title: s.maximized ? import_cli2.PANEL_LABELS.restore : import_cli2.PANEL_LABELS.maximize,
+                disabled: s.collapsed,
+                onClick: () => controller.toggleMaximize()
+              },
+              [icon(s.maximized ? import_cli2.RESTORE_ICON : import_cli2.MAXIMIZE_ICON)]
+            ),
+            (0, import_vue3.h)(
+              "button",
+              {
+                class: "cli-panel-btn",
+                title: s.collapsed ? import_cli2.PANEL_LABELS.expand : import_cli2.PANEL_LABELS.collapse,
+                onClick: () => controller.toggle()
+              },
+              [icon((0, import_cli2.collapseChevronIcon)(s.position, s.collapsed))]
+            ),
+            s.closable ? (0, import_vue3.h)("button", { class: "cli-panel-btn cli-panel-btn-close", title: import_cli2.PANEL_LABELS.close, onClick: () => controller.close() }, [icon(import_cli2.CLOSE_ICON)]) : null
+          ])
+        ]),
+        (0, import_vue3.h)("div", { class: (0, import_cli2.glowLineClass)(s) })
+      ]);
+    };
+    const renderTabs = (s) => (0, import_vue3.h)("div", { class: "cli-panel-tabs" }, [
+      (0, import_vue3.h)(
+        "ul",
+        { class: "cli-panel-tab-list" },
+        s.tabs.map(
+          (tab) => (0, import_vue3.h)(
+            "li",
+            {
+              key: tab.id,
+              class: (0, import_cli2.panelTabClass)(s, tab),
+              onClick: () => controller.selectTab(tab.id),
+              onDblclick: () => controller.startRename(tab.id),
+              onContextmenu: (e) => {
+                e.preventDefault();
+                e.stopPropagation();
+                controller.openContextMenu(tab.id, e.clientX, e.clientY);
+              }
+            },
+            tab.isEditing ? [
+              (0, import_vue3.h)("input", {
+                class: "cli-panel-tab-rename-input",
+                type: "text",
+                value: tab.title,
+                onVnodeMounted: (vnode) => {
+                  const input = vnode.el;
+                  input.focus();
+                  input.select();
+                },
+                onKeydown: (e) => (0, import_cli2.handleRenameKey)(controller, tab.id, e.key, e.target.value),
+                onBlur: (e) => controller.commitRename(tab.id, e.target.value),
+                onClick: stop,
+                onDblclick: stop
+              })
+            ] : [
+              (0, import_vue3.h)("span", { class: (0, import_cli2.panelTabDotClass)(s, tab) }),
+              (0, import_vue3.h)("span", { class: "cli-panel-tab-title" }, tab.title),
+              (0, import_vue3.h)(
+                "button",
+                {
+                  class: "cli-panel-tab-close-btn",
+                  title: import_cli2.PANEL_LABELS.closeTab,
+                  onClick: (e) => {
+                    e.stopPropagation();
+                    controller.closeTab(tab.id);
+                  }
+                },
+                import_cli2.CLOSE_GLYPH
+              )
+            ]
+          )
+        )
+      ),
+      (0, import_vue3.h)("button", { class: "cli-panel-add-tab", title: import_cli2.PANEL_LABELS.newTerminal, onClick: () => controller.addTab() }, "+")
+    ]);
+    const renderInstances = (s) => (0, import_vue3.h)(
+      "div",
+      { class: "cli-panel-instances" },
+      s.tabs.map(
+        (tab) => (0, import_vue3.h)("div", { key: tab.id, class: "cli-panel-instance", style: { display: tab.id === s.activeTabId ? void 0 : "none" } }, [
+          (0, import_vue3.h)(
+            "div",
+            { class: (0, import_cli2.panesContainerClass)(s) },
+            tab.panes.flatMap((pane, i) => [
+              i > 0 ? (0, import_vue3.h)(
+                "div",
+                {
+                  key: `divider-${pane.id}`,
+                  class: "cli-panel-pane-divider",
+                  onMousedown: (e) => {
+                    e.preventDefault();
+                    controller.startPaneResize(tab.id, i - 1, e.clientX, (0, import_cli2.panesContainerWidth)(e.target));
+                  }
+                },
+                [(0, import_vue3.h)("div", { class: "cli-panel-pane-divider-grip" })]
+              ) : null,
+              (0, import_vue3.h)(
+                "div",
+                {
+                  key: pane.id,
+                  class: (0, import_cli2.paneClass)(s, tab.id, pane.id),
+                  style: (0, import_cli2.paneStyle)(pane.widthPercent),
+                  onClick: () => controller.activatePane(tab.id, pane.id)
+                },
+                [
+                  tab.panes.length > 1 ? (0, import_vue3.h)(
+                    "button",
+                    {
+                      class: "cli-panel-pane-close-btn",
+                      title: import_cli2.PANEL_LABELS.closePane,
+                      onClick: (e) => {
+                        e.stopPropagation();
+                        controller.closePane(pane.id);
+                      }
+                    },
+                    import_cli2.CLOSE_GLYPH
+                  ) : null,
+                  (0, import_vue3.h)(Cli, {
+                    options: mergedOptions.value,
+                    modules: hostConfig.value.modules,
+                    processors: hostConfig.value.processors,
+                    services: hostConfig.value.services,
+                    snapshot: pane.snapshot,
+                    style: { height: "100%" },
+                    onReady: (engine) => controller.registerEngine(tab.id, pane.id, engine)
+                  })
+                ]
+              )
+            ])
+          )
+        ])
+      )
+    );
+    const renderContextMenu = (s) => (0, import_vue3.h)(
+      "div",
+      { class: "cli-panel-context-menu", style: (0, import_cli2.contextMenuStyle)(s), onClick: stop },
+      (0, import_cli2.contextMenuItems)(s).flatMap((item) => [
+        item.separatorBefore ? (0, import_vue3.h)("div", { class: "cli-panel-context-menu-separator" }) : null,
+        (0, import_vue3.h)(
+          "button",
+          {
+            class: (0, import_cli2.joinClasses)("cli-panel-context-menu-item", item.destructive && "destructive"),
+            disabled: item.disabled,
+            onClick: () => (0, import_cli2.runContextMenuAction)(controller, item.action)
+          },
+          item.label
+        )
+      ])
+    );
+    const renderStatusDropdown = (s) => {
+      const dropdown = (0, import_cli2.openStatusDropdown)(s);
+      if (!dropdown) return null;
+      return (0, import_vue3.h)("div", { class: "cli-panel-services-dropdown", style: dropdown.style, onClick: stop }, [
+        (0, import_vue3.h)("div", { class: "cli-panel-services-dropdown-header" }, dropdown.header),
+        (0, import_vue3.h)(
+          "div",
+          { class: "cli-panel-services-dropdown-list" },
+          dropdown.rows.map(
+            (row) => (0, import_vue3.h)("div", { key: row.key, class: "cli-panel-services-dropdown-item" }, [
+              (0, import_vue3.h)("span", { class: row.dotClass }),
+              (0, import_vue3.h)("div", { class: "cli-panel-svc-info" }, [
+                (0, import_vue3.h)("span", { class: "cli-panel-svc-name" }, row.name),
+                row.description ? (0, import_vue3.h)("span", { class: "cli-panel-svc-desc" }, row.description) : null
+              ]),
+              dropdown.kind === "servers" ? (0, import_vue3.h)("div", { class: "cli-panel-srv-meta" }, [
+                (0, import_vue3.h)("span", { class: "cli-panel-svc-status" }, row.status),
+                ...row.meta.map((m) => (0, import_vue3.h)("span", { key: m, class: "cli-panel-svc-desc" }, m))
+              ]) : (0, import_vue3.h)("span", { class: "cli-panel-svc-status" }, row.status)
+            ])
+          )
+        ),
+        dropdown.rows.length === 0 ? (0, import_vue3.h)("div", { class: "cli-panel-services-dropdown-empty" }, dropdown.emptyText) : null
+      ]);
+    };
+    return () => {
+      const s = state.value;
+      if (!s.visible) return null;
+      return (0, import_vue3.h)(import_vue3.Fragment, [
+        s.hidden ? (0, import_vue3.h)(
+          "button",
+          {
+            class: "cli-panel-hide-tab",
+            "data-position": s.position,
+            "data-hide-align": s.hideAlignment,
+            style: s.themeStyles,
+            title: import_cli2.PANEL_LABELS.showCli,
+            onClick: () => controller.unhide()
+          },
+          [
+            icon(import_cli2.HIDE_TAB_TERMINAL_ICON, "cli-panel-hide-tab-icon"),
+            (0, import_vue3.h)("span", { class: "cli-panel-hide-tab-label" }, import_cli2.PANEL_LABELS.title),
+            icon((0, import_cli2.hideTabChevronIcon)(s.position), "cli-panel-hide-tab-arrow")
+          ]
+        ) : null,
+        (0, import_vue3.h)(
+          "div",
+          {
+            ref: root,
+            class: (0, import_cli2.panelWrapperClass)(s, props.class),
+            style: { ...(0, import_cli2.panelWrapperStyle)(s), ...props.style },
+            "data-position": s.position,
+            "data-resizable": String(s.resizable),
+            "data-closable": String(s.closable),
+            "data-hideable": String(s.hideable)
+          },
+          [
+            renderHeader(s),
+            s.initialized ? (0, import_vue3.h)("div", { class: "cli-panel-content", style: s.collapsed ? { display: "none" } : void 0 }, [
+              renderTabs(s),
+              renderInstances(s)
+            ]) : null
+          ]
+        ),
+        s.contextMenu.visible ? renderContextMenu(s) : null,
+        renderStatusDropdown(s)
+      ]);
+    };
+  }
+});
+
+// src/CliProvider.ts
+var import_vue5 = require("vue");
+
+// src/useCliEngine.ts
+var import_vue4 = require("vue");
+var import_cli3 = 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 = (0, import_cli3.createCliEngine)(containerRef.value, { ...config, framework: "Vue" });
+    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_cli4 = 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