@scalar/api-client 2.18.0 → 2.18.3

package/dist/components/CodeInput/CodeInput.vue2.js

@@ -1,9 +1,9 @@
-import { defineComponent as W, useAttrs as j, ref as i, computed as d, toRef as r, watch as H, createElementBlock as u, openBlock as n, Fragment as Q, createBlock as c, createCommentVNode as p, normalizeClass as G, unref as h, createElementVNode as w, toDisplayString as J, mergeProps as X, withKeys as b, withModifiers as $, createTextVNode as V, renderSlot as q } from "vue";
+import { defineComponent as W, useAttrs as j, ref as d, computed as p, toRef as s, watch as H, createElementBlock as i, openBlock as a, Fragment as Q, createBlock as b, createCommentVNode as f, normalizeClass as G, unref as w, createElementVNode as V, toDisplayString as J, mergeProps as X, withKeys as y, withModifiers as q, createTextVNode as x, renderSlot as R } from "vue";
 import { useCodeMirror as Y, useDropdown as Z, colorPicker as _ } from "@scalar/use-codemirror";
 import { nanoid as ee } from "nanoid";
-import oe from "../../views/Environment/EnvironmentVariableDropdown.vue.js";
-import x from "../DataTable/DataTableInputSelect.vue.js";
-import { pillPlugin as le, backspaceCommand as te } from "./codeVariableWidget.js";
+import te from "../../views/Environment/EnvironmentVariableDropdown.vue.js";
+import B from "../DataTable/DataTableInputSelect.vue.js";
+import { pillPlugin as oe, backspaceCommand as le } from "./codeVariableWidget.js";
 import { useLayout as ne } from "../../hooks/useLayout.js";
 const ae = { class: "whitespace-nowrap" }, re = ["id"], se = {
   key: 0,
@@ -52,155 +52,155 @@ const ae = { class: "whitespace-nowrap" }, re = ["id"], se = {
     lineWrapping: { type: Boolean, default: !1 }
   },
   emits: ["submit", "update:modelValue", "curl", "blur"],
-  setup(R, { expose: A, emit: I }) {
-    const o = R, s = I, B = j(), M = B.id || `id-${ee()}`, k = i(!1), y = i(!1), C = i(""), S = i({ left: 0, top: 0 }), f = i(null), { layout: g } = ne();
-    function D(e) {
-      return e === o.modelValue ? null : o.importCurl && e.trim().toLowerCase().startsWith("curl") ? (s("curl", e), a.value?.dispatch({
+  setup(l, { expose: A, emit: I }) {
+    const e = l, u = I, k = j(), M = k.id || `id-${ee()}`, C = d(!1), g = d(!1), S = d(""), D = d({ left: 0, top: 0 }), m = d(null), { layout: v } = ne();
+    function P(t) {
+      return t === e.modelValue ? null : e.importCurl && t.trim().toLowerCase().startsWith("curl") ? (u("curl", t), r.value?.dispatch({
         changes: {
           from: 0,
-          to: a.value.state.doc.length,
-          insert: String(o.modelValue)
+          to: r.value.state.doc.length,
+          insert: String(e.modelValue)
         }
-      }), null) : o.handleFieldChange ? o.handleFieldChange(e) : s("update:modelValue", e);
+      }), null) : e.handleFieldChange ? e.handleFieldChange(t) : u("update:modelValue", t);
     }
-    function v(e) {
-      return o.handleFieldSubmit ? o.handleFieldSubmit(e) : s("submit", e);
+    function h(t) {
+      return e.handleFieldSubmit ? e.handleFieldSubmit(t) : u("submit", t);
     }
-    function P(e) {
-      k.value = !1, o.emitOnBlur && o.modelValue && v(e), s("blur", e);
+    function E(t) {
+      C.value = !1, e.emitOnBlur && e.modelValue && h(t), u("blur", t);
     }
-    const E = [...o.extensions];
-    o.colorPicker && E.push(_);
-    const N = d(
-      () => le({
-        environment: o.environment,
-        envVariables: o.envVariables,
-        isReadOnly: g === "modal"
+    const F = [...e.extensions];
+    e.colorPicker && F.push(_);
+    const N = p(
+      () => oe({
+        environment: e.environment,
+        envVariables: e.envVariables,
+        isReadOnly: v === "modal"
       })
-    ), O = d(() => [
-      ...E,
+    ), O = p(() => [
+      ...F,
       N.value,
-      te
-    ]), F = i(null), { codeMirror: a } = Y({
-      content: r(
-        () => o.modelValue !== void 0 ? String(o.modelValue) : ""
+      le
+    ]), T = d(null), { codeMirror: r } = Y({
+      content: s(
+        () => e.modelValue !== void 0 ? String(e.modelValue) : ""
       ),
-      onChange: (e) => {
-        D(e), z();
+      onChange: (t) => {
+        P(t), z();
       },
-      onFocus: () => k.value = !0,
-      onBlur: (e) => P(e),
-      codeMirrorRef: F,
-      disableTabIndent: r(() => o.disableTabIndent),
-      disableEnter: r(() => o.disableEnter),
-      disableCloseBrackets: r(() => o.disableCloseBrackets),
-      lineNumbers: r(() => o.lineNumbers),
-      language: r(() => o.language),
-      lint: r(() => o.lint),
+      onFocus: () => C.value = !0,
+      onBlur: (t) => E(t),
+      codeMirrorRef: T,
+      disableTabIndent: s(() => e.disableTabIndent),
+      disableEnter: s(() => e.disableEnter),
+      disableCloseBrackets: s(() => e.disableCloseBrackets),
+      lineNumbers: s(() => e.lineNumbers),
+      language: s(() => e.language),
+      lint: s(() => e.lint),
       extensions: O,
-      placeholder: r(() => o.placeholder)
+      placeholder: s(() => e.placeholder)
     });
-    a.value?.focus(), H(a, () => {
-      a.value && Object.hasOwn(B, "autofocus") && a.value.focus();
+    r.value?.focus(), H(r, () => {
+      r.value && Object.hasOwn(k, "autofocus") && r.value.focus();
     });
     const { handleDropdownSelect: K, updateDropdownVisibility: z } = Z({
-      codeMirror: a,
-      query: C,
-      showDropdown: y,
-      dropdownPosition: S
-    }), T = d(
-      () => o.nullable ? ["true", "false", "null"] : ["true", "false"]
-    ), m = (e, l) => {
-      y.value ? e === "down" ? (l.preventDefault(), f.value?.handleArrowKey("down")) : e === "up" ? (l.preventDefault(), f.value?.handleArrowKey("up")) : e === "enter" && (l.preventDefault(), f.value?.handleSelect()) : e === "escape" ? o.disableTabIndent || l.stopPropagation() : e === "enter" && l.target instanceof HTMLDivElement && v(l.target.textContent ?? "");
-    }, L = d(() => Array.isArray(o.type) ? (
+      codeMirror: r,
+      query: S,
+      showDropdown: g,
+      dropdownPosition: D
+    }), $ = p(
+      () => e.nullable ? ["true", "false", "null"] : ["true", "false"]
+    ), c = (t, o) => {
+      g.value ? t === "down" ? (o.preventDefault(), m.value?.handleArrowKey("down")) : t === "up" ? (o.preventDefault(), m.value?.handleArrowKey("up")) : t === "enter" && (o.preventDefault(), m.value?.handleSelect()) : t === "escape" ? e.disableTabIndent || o.stopPropagation() : t === "enter" && o.target instanceof HTMLDivElement && h(o.target.textContent ?? "");
+    }, L = p(() => Array.isArray(e.type) ? (
       // Find the first type, that's not 'null'
-      o.type.find((e) => e !== "null") ?? "string"
+      e.type.find((t) => t !== "null") ?? "string"
     ) : (
       // If it's not an array, just return the type
-      o.type
-    )), U = d(
-      () => y.value && o.withVariables && g !== "modal" && o.environment
+      e.type
+    )), U = p(
+      () => g.value && e.withVariables && v !== "modal" && e.environment
     );
     return A({
       /** Expose focus method */
       focus: () => {
-        a.value?.focus();
+        r.value?.focus();
       },
       // Expose these methods for testing
-      handleChange: D,
-      handleSubmit: v,
-      handleBlur: P,
-      booleanOptions: T,
-      codeMirror: a,
-      modelValue: o.modelValue
-    }), (e, l) => (n(), u(Q, null, [
-      e.disabled ? (n(), u("div", {
+      handleChange: P,
+      handleSubmit: h,
+      handleBlur: E,
+      booleanOptions: $,
+      codeMirror: r,
+      modelValue: e.modelValue
+    }), (t, o) => (a(), i(Q, null, [
+      l.disabled ? (a(), i("div", {
         key: 0,
-        class: G(["text-c-2 flex cursor-default items-center justify-center", h(g) === "modal" ? "font-code pr-2 pl-1 text-base" : "px-2"]),
+        class: G(["text-c-2 flex cursor-default items-center justify-center", w(v) === "modal" ? "font-code pr-2 pl-1 text-base" : "px-2"]),
         "data-testid": "code-input-disabled"
       }, [
-        w("span", ae, J(e.modelValue), 1)
-      ], 2)) : o.enum && o.enum.length ? (n(), c(x, {
+        V("span", ae, J(l.modelValue), 1)
+      ], 2)) : e.enum && e.enum.length ? (a(), b(B, {
         key: 1,
-        default: o.default,
-        modelValue: e.modelValue,
+        default: e.default,
+        modelValue: l.modelValue,
         type: L.value,
-        value: o.enum,
-        "onUpdate:modelValue": l[0] || (l[0] = (t) => s("update:modelValue", t))
-      }, null, 8, ["default", "modelValue", "type", "value"])) : e.type === "boolean" || e.type?.includes("boolean") ? (n(), c(x, {
+        value: e.enum,
+        "onUpdate:modelValue": o[0] || (o[0] = (n) => u("update:modelValue", n))
+      }, null, 8, ["default", "modelValue", "type", "value"])) : l.type === "boolean" || l.type?.includes("boolean") ? (a(), b(B, {
         key: 2,
-        default: o.default,
-        modelValue: e.modelValue,
-        value: T.value,
-        "onUpdate:modelValue": l[1] || (l[1] = (t) => s("update:modelValue", t))
-      }, null, 8, ["default", "modelValue", "value"])) : o.examples && o.examples.length ? (n(), c(x, {
+        default: e.default,
+        modelValue: l.modelValue,
+        value: $.value,
+        "onUpdate:modelValue": o[1] || (o[1] = (n) => u("update:modelValue", n))
+      }, null, 8, ["default", "modelValue", "value"])) : e.examples && e.examples.length ? (a(), b(B, {
         key: 3,
-        default: o.default,
-        modelValue: o.modelValue,
-        value: o.examples,
-        "onUpdate:modelValue": l[2] || (l[2] = (t) => s("update:modelValue", t))
-      }, null, 8, ["default", "modelValue", "value"])) : (n(), u("div", X({
+        default: e.default,
+        modelValue: e.modelValue,
+        value: e.examples,
+        "onUpdate:modelValue": o[2] || (o[2] = (n) => u("update:modelValue", n))
+      }, null, 8, ["default", "modelValue", "value"])) : (a(), i("div", X({
         key: 4,
-        id: h(M)
-      }, e.$attrs, {
+        id: w(M)
+      }, t.$attrs, {
         ref_key: "codeMirrorRef",
-        ref: F,
+        ref: T,
         class: ["group/input group-[.alert]:outline-orange group-[.error]:outline-red font-code peer relative w-full overflow-hidden text-xs leading-[1.44] whitespace-nowrap -outline-offset-1 has-[:focus-visible]:rounded-[4px] has-[:focus-visible]:outline", {
-          "line-wrapping has-[:focus-visible]:bg-b-1 has-[:focus-visible]:absolute has-[:focus-visible]:z-1": e.lineWrapping,
-          "flow-code-input--error": e.error
+          "line-wrapping has-[:focus-visible]:bg-b-1 has-[:focus-visible]:absolute has-[:focus-visible]:z-1": l.lineWrapping,
+          "flow-code-input--error": l.error
         }],
         onKeydown: [
-          l[3] || (l[3] = b($((t) => m("down", t), ["stop"]), ["down"])),
-          l[4] || (l[4] = b((t) => m("enter", t), ["enter"])),
-          l[5] || (l[5] = b((t) => m("escape", t), ["escape"])),
-          l[6] || (l[6] = b($((t) => m("up", t), ["stop"]), ["up"]))
+          o[3] || (o[3] = y(q((n) => c("down", n), ["stop"]), ["down"])),
+          o[4] || (o[4] = y((n) => c("enter", n), ["enter"])),
+          o[5] || (o[5] = y((n) => c("escape", n), ["escape"])),
+          o[6] || (o[6] = y(q((n) => c("up", n), ["stop"]), ["up"]))
         ]
       }), [
-        e.disableTabIndent ? p("", !0) : (n(), u("div", se, [...l[7] || (l[7] = [
-          V(" Press ", -1),
-          w("kbd", { class: "-mx-0.25 rounded border px-0.5 font-mono" }, "Esc", -1),
-          V(" then ", -1),
-          w("kbd", { class: "-mx-0.25 rounded border px-0.5 font-mono" }, "Tab", -1),
-          V(" to exit ", -1)
+        l.disableTabIndent ? f("", !0) : (a(), i("div", se, [...o[7] || (o[7] = [
+          x(" Press ", -1),
+          V("kbd", { class: "-mx-0.25 rounded border px-0.5 font-mono" }, "Esc", -1),
+          x(" then ", -1),
+          V("kbd", { class: "-mx-0.25 rounded border px-0.5 font-mono" }, "Tab", -1),
+          x(" to exit ", -1)
         ])]))
       ], 16, re)),
-      e.$slots.warning ? (n(), u("div", ue, [
-        q(e.$slots, "warning", {}, void 0, !0)
-      ])) : p("", !0),
-      e.$slots.icon ? (n(), u("div", ie, [
-        q(e.$slots, "icon", {}, void 0, !0)
-      ])) : p("", !0),
-      e.required ? (n(), u("div", de, " Required ")) : p("", !0),
-      U.value ? (n(), c(oe, {
+      t.$slots.warning ? (a(), i("div", ue, [
+        R(t.$slots, "warning", {}, void 0, !0)
+      ])) : f("", !0),
+      t.$slots.icon ? (a(), i("div", ie, [
+        R(t.$slots, "icon", {}, void 0, !0)
+      ])) : f("", !0),
+      l.required ? (a(), i("div", de, " Required ")) : f("", !0),
+      U.value ? (a(), b(te, {
         key: 8,
         ref_key: "dropdownRef",
-        ref: f,
-        dropdownPosition: S.value,
-        envVariables: e.envVariables,
-        environment: e.environment,
-        query: C.value,
-        onSelect: h(K)
-      }, null, 8, ["dropdownPosition", "envVariables", "environment", "query", "onSelect"])) : p("", !0)
+        ref: m,
+        dropdownPosition: D.value,
+        envVariables: l.envVariables,
+        environment: l.environment,
+        query: S.value,
+        onSelect: w(K)
+      }, null, 8, ["dropdownPosition", "envVariables", "environment", "query", "onSelect"])) : f("", !0)
     ], 64));
   }
 });

package/dist/components/CommandPalette/CommandActionForm.vue.js

@@ -1,36 +1,36 @@
-import { defineComponent as i, createElementBlock as n, openBlock as r, withModifiers as l, withKeys as m, createElementVNode as t, normalizeProps as p, guardReactiveProps as f, unref as d, renderSlot as s, createVNode as u, withCtx as b, createTextVNode as x } from "vue";
-import { useBindCx as c, ScalarButton as v } from "@scalar/components";
-const w = { class: "flex gap-2" }, B = { class: "flex max-h-8 flex-1" }, h = /* @__PURE__ */ i({
+import { defineComponent as n, createElementBlock as r, openBlock as m, withModifiers as d, withKeys as f, createElementVNode as l, normalizeProps as u, guardReactiveProps as p, unref as a, renderSlot as s, createVNode as x, withCtx as b, createTextVNode as c } from "vue";
+import { useBindCx as v, ScalarButton as w } from "@scalar/components";
+const B = { class: "flex gap-2" }, C = { class: "flex max-h-8 flex-1" }, h = /* @__PURE__ */ n({
   __name: "CommandActionForm",
   props: {
     loader: {},
     disabled: { type: Boolean, default: !1 }
   },
   emits: ["submit", "cancel", "back"],
-  setup(C) {
-    const { cx: a } = c();
-    return (e, o) => (r(), n("form", {
+  setup(o) {
+    const { cx: i } = v();
+    return (t, e) => (m(), r("form", {
       class: "flex w-full flex-col gap-3",
-      onKeydown: o[0] || (o[0] = m(l(() => {
+      onKeydown: e[0] || (e[0] = f(d(() => {
       }, ["stop"]), ["enter"])),
-      onSubmit: o[1] || (o[1] = l(($) => !e.disabled && e.$emit("submit"), ["prevent", "stop"]))
+      onSubmit: e[1] || (e[1] = d(($) => !o.disabled && t.$emit("submit"), ["prevent", "stop"]))
     }, [
-      t("div", p(f(d(a)("relative flex min-h-20 flex-col rounded"))), [
-        s(e.$slots, "default")
+      l("div", u(p(a(i)("relative flex min-h-20 flex-col rounded"))), [
+        s(t.$slots, "default")
       ], 16),
-      t("div", w, [
-        t("div", B, [
-          s(e.$slots, "options")
+      l("div", B, [
+        l("div", C, [
+          s(t.$slots, "options")
         ]),
-        u(d(v), {
+        x(a(w), {
           class: "max-h-8 px-3 text-xs",
-          disabled: e.disabled,
-          loader: e.loader,
+          disabled: o.disabled,
+          loader: o.loader,
           type: "submit"
         }, {
           default: b(() => [
-            s(e.$slots, "submit", {}, () => [
-              o[2] || (o[2] = x("Continue", -1))
+            s(t.$slots, "submit", {}, () => [
+              e[2] || (e[2] = c("Continue", -1))
             ])
           ]),
           _: 3

package/dist/components/CommandPalette/CommandPaletteImportCurl.vue2.js

@@ -1,11 +1,11 @@
-import { defineComponent as I, ref as D, computed as B, useTemplateRef as O, createElementBlock as V, openBlock as W, Fragment as L, createElementVNode as r, createVNode as o, withCtx as i, toDisplayString as m, unref as c, normalizeClass as M } from "vue";
+import { defineComponent as I, ref as x, computed as B, useTemplateRef as O, createElementBlock as V, openBlock as W, Fragment as L, createElementVNode as r, createVNode as o, withCtx as i, toDisplayString as m, unref as c, normalizeClass as M } from "vue";
 import { ScalarListbox as P, ScalarButton as j, ScalarIcon as z } from "@scalar/components";
 import { REGEX as F } from "@scalar/oas-utils/helpers";
 import { emitCustomEvent as N } from "@scalar/workspace-store/events";
 import { useRouter as T } from "vue-router";
 import $ from "./CommandActionForm.vue.js";
 import A from "../HttpMethod/HttpMethod.vue.js";
-import { PathId as p } from "../../routes.js";
+import { PathId as f } from "../../routes.js";
 import { useActiveEntities as G } from "../../store/active-entities.js";
 import { useWorkspace as H } from "../../store/store.js";
 const X = { class: "flex h-9 flex-row items-center gap-2 rounded border p-[3px] text-sm" }, J = { class: "flex h-full" }, K = { class: "scroll-timeline-x whitespace-nowrap" }, Q = { class: "flex" }, ie = /* @__PURE__ */ I({
@@ -14,35 +14,35 @@ const X = { class: "flex h-9 flex-row items-center gap-2 rounded border p-[3px]
     metaData: {}
   },
   emits: ["close", "back"],
-  setup(e, { emit: x }) {
-    const w = x, b = H(), { activeWorkspaceCollections: f, activeCollection: S, activeWorkspace: v } = G(), { requestMutators: k, serverMutators: q, servers: R } = b, d = D(""), U = T(), n = B(
-      () => f.value.map((t) => ({
-        id: t.uid,
-        label: t.info?.title ?? "Unititled Collection"
+  setup(e, { emit: D }) {
+    const w = D, b = H(), { activeWorkspaceCollections: p, activeCollection: S, activeWorkspace: v } = G(), { requestMutators: k, serverMutators: q, servers: R } = b, d = x(""), U = T(), n = B(
+      () => p.value.map((a) => ({
+        id: a.uid,
+        label: a.info?.title ?? "Unititled Collection"
       }))
-    ), l = D(
+    ), l = x(
       e.metaData.collectionUid ? n.value.find(
-        (t) => t.id === e.metaData.collectionUid
+        (a) => a.id === e.metaData.collectionUid
       ) : n.value.find(
-        (t) => t.id === S.value?.uid
+        (a) => a.id === S.value?.uid
       )
     );
-    function g({ collectionUid: t }) {
+    function g({ collectionUid: a }) {
       if (!e.metaData.parsedCurl)
         return;
-      const a = f.value.find(
-        (u) => u.uid === t
+      const t = p.value.find(
+        (u) => u.uid === a
       );
-      if (!a)
+      if (!t)
         return;
-      const s = a?.info?.title === "Drafts";
+      const s = t?.info?.title === "Drafts";
       if (!s && e.metaData.parsedCurl.servers) {
         const u = Object.values(R).find(
           (y) => y.url === e.metaData.parsedCurl?.servers?.[0]
         );
         u ? d.value = u.uid : (d.value = q.add(
           { url: e.metaData.parsedCurl.servers[0] ?? "/" },
-          a.uid
+          t.uid
         ).uid, N(E.value?.$el, "scalar-add-server", {
           server: { url: e.metaData.parsedCurl.servers[0] ?? "/" },
           options: {
@@ -59,14 +59,14 @@ const X = { class: "flex h-9 flex-row items-center gap-2 rounded border p-[3px]
           selectedServerUid: s ? void 0 : d.value,
           requestBody: e.metaData.parsedCurl?.requestBody
         },
-        a.uid
+        t.uid
       );
       h && v.value?.uid && U.push({
         name: "request",
         params: {
-          [p.Workspace]: v.value.uid,
-          [p.Collection]: a.uid,
-          [p.Request]: h.uid
+          [f.Workspace]: v.value.uid,
+          [f.Collection]: t.uid,
+          [f.Request]: h.uid
         }
       }), w("close");
     }
@@ -75,8 +75,8 @@ const X = { class: "flex h-9 flex-row items-center gap-2 rounded border p-[3px]
         collectionUid: l.value?.id ?? ""
       });
     }, E = O("wrapper-ref");
-    return (t, a) => (W(), V(L, null, [
-      a[1] || (a[1] = r("div", { class: "text-c-2 flex-center py-1.5 text-sm" }, "Import cURL", -1)),
+    return (a, t) => (W(), V(L, null, [
+      t[1] || (t[1] = r("div", { class: "text-c-2 flex-center py-1.5 text-sm" }, "Import cURL", -1)),
       o($, {
         ref: "wrapper-ref",
         class: "mt-1.5 min-h-fit",
@@ -86,7 +86,7 @@ const X = { class: "flex h-9 flex-row items-center gap-2 rounded border p-[3px]
           r("div", Q, [
             o(c(P), {
               modelValue: l.value,
-              "onUpdate:modelValue": a[0] || (a[0] = (s) => l.value = s),
+              "onUpdate:modelValue": t[0] || (t[0] = (s) => l.value = s),
               options: n.value
             }, {
               default: i(() => [
@@ -120,10 +120,10 @@ const X = { class: "flex h-9 flex-row items-center gap-2 rounded border p-[3px]
               o(A, {
                 isEditable: !1,
                 isSquare: "",
-                method: t.metaData.parsedCurl?.method || "get"
+                method: e.metaData.parsedCurl?.method || "get"
               }, null, 8, ["method"])
             ]),
-            r("span", K, m(t.metaData.parsedCurl?.servers?.[0] || "") + m(t.metaData.parsedCurl?.path || ""), 1)
+            r("span", K, m(e.metaData.parsedCurl?.servers?.[0] || "") + m(e.metaData.parsedCurl?.path || ""), 1)
           ])
         ]),
         _: 1

package/dist/components/CommandPalette/TheCommandPalette.vue.d.ts

@@ -5,7 +5,7 @@
  */
 declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 export default _default;
-export declare const PaletteComponents: {
+declare const PaletteComponents: {
     readonly 'Import from OpenAPI/Swagger/Postman/cURL': import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
         close: () => any;
         back: (e: KeyboardEvent) => any;
@@ -206,7 +206,7 @@ export declare const PaletteComponents: {
     }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 };
 /** Infer the types from the commands  */
-export type CommandNames = keyof typeof PaletteComponents;
+type CommandNames = keyof typeof PaletteComponents;
 export type CommandPaletteEvent = {
     /** The command name which matches with the command palette */
     commandName?: CommandNames;

package/dist/components/CommandPalette/TheCommandPalette.vue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TheCommandPalette.vue.d.ts","sourceRoot":"","sources":["../../../src/components/CommandPalette/TheCommandPalette.vue"],"names":[],"mappings":"AAqfA;;;;GAIG;;AACH,wBA8lBI;AAEJ,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;mBA7nB9B,CA5TmB;qBA4TnB,CA3Ta;;;;;;;mBA2Tb,CA5TmB;qBA4TnB,CA3Ta;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAi8BH,CAAA;AAEV,yCAAyC;AACzC,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,iBAAiB,CAAA;AAEzD,MAAM,MAAM,mBAAmB,GAAG;IAChC,8DAA8D;IAC9D,WAAW,CAAC,EAAE,YAAY,CAAA;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAC/B,CACA"}
+{"version":3,"file":"TheCommandPalette.vue.d.ts","sourceRoot":"","sources":["../../../src/components/CommandPalette/TheCommandPalette.vue"],"names":[],"mappings":"AAqfA;;;;GAIG;;AACH,wBA8lBI;AAEJ,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;mBA7nBvB,CA3TI;qBA2TJ,CA3T2B;;;;;;;mBA2T3B,CA3TI;qBA2TJ,CA3T2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAi8BjB,CAAA;AAEV,yCAAyC;AACzC,KAAK,YAAY,GAAG,MAAM,OAAO,iBAAiB,CAAA;AAElD,MAAM,MAAM,mBAAmB,GAAG;IAChC,8DAA8D;IAC9D,WAAW,CAAC,EAAE,YAAY,CAAA;IAC1B,iEAAiE;IACjE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAC/B,CACA"}

package/dist/components/CommandPalette/TheCommandPalette.vue.js

@@ -1,9 +1,7 @@
 import o from "./TheCommandPalette.vue2.js";
-import { PaletteComponents as s } from "./TheCommandPalette.vue2.js";
 /* empty css                       */
 import t from "../../_virtual/_plugin-vue_export-helper.js";
-const a = /* @__PURE__ */ t(o, [["__scopeId", "data-v-f2bbd082"]]);
+const r = /* @__PURE__ */ t(o, [["__scopeId", "data-v-dd90fe74"]]);
 export {
-  s as PaletteComponents,
-  a as default
+  r as default
 };

package/dist/components/CommandPalette/TheCommandPalette.vue2.js

@@ -301,6 +301,5 @@ const Ie = {
   }
 });
 export {
-  We as PaletteComponents,
   Ye as default
 };

package/dist/components/CommandPalette/WatchModeToggle.vue.js

@@ -1,35 +1,35 @@
-import { defineComponent as c, computed as p, createElementBlock as i, openBlock as f, normalizeClass as a, createElementVNode as V, createVNode as d, createTextVNode as g, unref as s } from "vue";
+import { defineComponent as r, computed as i, createElementBlock as p, openBlock as f, normalizeClass as d, createElementVNode as V, createVNode as n, createTextVNode as g, unref as s } from "vue";
 import { ScalarIcon as x, ScalarToggle as b } from "@scalar/components";
-const N = /* @__PURE__ */ c({
+const N = /* @__PURE__ */ r({
   __name: "WatchModeToggle",
   props: {
     modelValue: { type: Boolean },
     disabled: { type: Boolean, default: !1 }
   },
   emits: ["update:modelValue"],
-  setup(n, { emit: m }) {
-    const r = n, l = m, o = p({
-      get: () => r.modelValue,
-      set: (e) => l("update:modelValue", e)
+  setup(t, { emit: m }) {
+    const u = t, l = m, o = i({
+      get: () => u.modelValue,
+      set: (a) => l("update:modelValue", a)
     });
-    return (e, t) => (f(), i("label", {
-      class: a(["text-c-2 flex items-center gap-2 rounded p-3 py-1.5 text-sm select-none", e.disabled ? "cursor-default" : "cursor-pointer"]),
+    return (a, e) => (f(), p("label", {
+      class: d(["text-c-2 flex items-center gap-2 rounded p-3 py-1.5 text-sm select-none", t.disabled ? "cursor-default" : "cursor-pointer"]),
       for: "watch-toggle"
     }, [
       V("span", {
-        class: a(["text-c-1 flex items-center gap-1 text-xs font-medium", { "text-c-3": !o.value }])
+        class: d(["text-c-1 flex items-center gap-1 text-xs font-medium", { "text-c-3": !o.value }])
       }, [
-        d(s(x), {
+        n(s(x), {
           icon: "Watch",
           size: "sm"
         }),
-        t[1] || (t[1] = g(" Watch Mode ", -1))
+        e[1] || (e[1] = g(" Watch Mode ", -1))
       ], 2),
-      d(s(b), {
+      n(s(b), {
         id: "watch-toggle",
-        disabled: !!e.disabled,
+        disabled: !!t.disabled,
         modelValue: o.value,
-        "onUpdate:modelValue": t[0] || (t[0] = (u) => l("update:modelValue", u))
+        "onUpdate:modelValue": e[0] || (e[0] = (c) => l("update:modelValue", c))
       }, null, 8, ["disabled", "modelValue"])
     ], 2));
   }

package/dist/components/DataTable/DataTable.vue.js

@@ -1,38 +1,38 @@
-import { defineComponent as r, createElementBlock as o, openBlock as l, normalizeProps as n, guardReactiveProps as i, unref as m, createElementVNode as p, normalizeStyle as c, normalizeClass as u, createCommentVNode as d, renderSlot as t } from "vue";
-import { useBindCx as f } from "@scalar/components";
-const b = ["role"], y = {
+import { defineComponent as r, createElementBlock as t, openBlock as l, normalizeProps as c, guardReactiveProps as i, unref as m, createElementVNode as u, normalizeStyle as d, normalizeClass as p, createCommentVNode as f, renderSlot as a } from "vue";
+import { useBindCx as b } from "@scalar/components";
+const y = ["role"], v = {
   key: 0,
   class: "sr-only"
-}, _ = /* @__PURE__ */ r({
+}, h = /* @__PURE__ */ r({
   __name: "DataTable",
   props: {
     columns: {},
     scroll: { type: Boolean },
     presentational: { type: Boolean }
   },
-  setup(v) {
-    const { cx: a } = f();
-    return (e, w) => (l(), o("div", n(i(
-      m(a)(
+  setup(e) {
+    const { cx: n } = b();
+    return (o, w) => (l(), t("div", c(i(
+      m(n)(
         e.scroll ? "overflow-x-auto custom-scroll" : "overflow-visible",
         "scalar-data-table"
       )
     )), [
-      p("table", {
-        class: u(["mb-0 grid min-h-8 auto-rows-auto", { "w-max min-w-full": e.scroll }]),
+      u("table", {
+        class: p(["mb-0 grid min-h-8 auto-rows-auto", { "w-max min-w-full": e.scroll }]),
         role: e.presentational ? "presentation" : "table",
-        style: c({
+        style: d({
           gridTemplateColumns: e.columns.map((s) => s || "1fr").join(" ")
         })
       }, [
-        e.$slots.caption ? (l(), o("caption", y, [
-          t(e.$slots, "caption")
-        ])) : d("", !0),
-        t(e.$slots, "default")
-      ], 14, b)
+        o.$slots.caption ? (l(), t("caption", v, [
+          a(o.$slots, "caption")
+        ])) : f("", !0),
+        a(o.$slots, "default")
+      ], 14, y)
     ], 16));
   }
 });
 export {
-  _ as default
+  h as default
 };