@equal-experts/kuat-vue 0.4.2 → 0.6.0

package/dist/KuatSelect.vue_vue_type_script_setup_true_lang-DP66U_wg.js

@@ -0,0 +1,493 @@
+import { defineComponent as f, createBlock as i, openBlock as l, unref as s, mergeProps as _, withCtx as n, renderSlot as u, createVNode as c, computed as z, createElementBlock as g, createCommentVNode as v, createElementVNode as I, createTextVNode as y, toDisplayString as h, useAttrs as T, normalizeClass as H, Fragment as k, renderList as P } from "vue";
+import { c as m } from "./utils-DLUjLwnh.js";
+import { useForwardPropsEmits as x, SelectRoot as L, SelectScrollDownButton as O, SelectScrollUpButton as N, SelectPortal as U, SelectContent as D, SelectViewport as F, SelectGroup as A, SelectItem as G, SelectItemText as q, SelectItemIndicator as j, SelectLabel as K, SelectSeparator as M, SelectTrigger as R, SelectIcon as W, SelectValue as Z } from "reka-ui";
+import { ChevronDown as E, ChevronUp as J, Check as Q } from "lucide-vue-next";
+import { r as S } from "./index-A7umpmtg.js";
+const $e = ["regular", "large", "small", "mini"], Be = ["single", "double"];
+function X(a) {
+  return "items" in a;
+}
+const Y = /* @__PURE__ */ f({
+  __name: "Select",
+  props: {
+    open: { type: Boolean },
+    defaultOpen: { type: Boolean },
+    defaultValue: {},
+    modelValue: {},
+    by: { type: [String, Function] },
+    dir: {},
+    multiple: { type: Boolean },
+    autocomplete: {},
+    disabled: { type: Boolean },
+    name: {},
+    required: { type: Boolean }
+  },
+  emits: ["update:modelValue", "update:open"],
+  setup(a, { emit: t }) {
+    const o = x(a, t);
+    return (d, B) => (l(), i(s(L), _({ "data-slot": "select" }, s(o)), {
+      default: n(() => [
+        u(d.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), ee = /* @__PURE__ */ f({
+  __name: "SelectScrollDownButton",
+  props: {
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(a) {
+    const t = a, e = S(t, "class");
+    return (r, o) => (l(), i(s(O), _({ "data-slot": "select-scroll-down-button" }, s(e), {
+      class: s(m)("select-scroll-button", t.class)
+    }), {
+      default: n(() => [
+        c(s(E), {
+          class: "size-4",
+          "aria-hidden": "true"
+        })
+      ]),
+      _: 1
+    }, 16, ["class"]));
+  }
+}), te = /* @__PURE__ */ f({
+  __name: "SelectScrollUpButton",
+  props: {
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(a) {
+    const t = a, e = S(t, "class");
+    return (r, o) => (l(), i(s(N), _({ "data-slot": "select-scroll-up-button" }, s(e), {
+      class: s(m)("select-scroll-button", t.class)
+    }), {
+      default: n(() => [
+        c(s(J), {
+          class: "size-4",
+          "aria-hidden": "true"
+        })
+      ]),
+      _: 1
+    }, 16, ["class"]));
+  }
+}), se = /* @__PURE__ */ f({
+  __name: "SelectContent",
+  props: {
+    forceMount: { type: Boolean },
+    position: { default: "item-aligned" },
+    bodyLock: { type: Boolean },
+    side: {},
+    sideOffset: {},
+    sideFlip: { type: Boolean },
+    align: {},
+    alignOffset: {},
+    alignFlip: { type: Boolean },
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean },
+    positionStrategy: {},
+    updatePositionStrategy: {},
+    disableUpdateOnLayoutShift: { type: Boolean },
+    prioritizePosition: { type: Boolean },
+    reference: {},
+    asChild: { type: Boolean },
+    as: {},
+    disableOutsidePointerEvents: { type: Boolean },
+    class: {},
+    size: { default: "regular" },
+    maxHeight: { default: 320 }
+  },
+  setup(a) {
+    const t = a, e = S(t, "class", "size", "maxHeight"), r = z(() => ({
+      "--kuat-select-content-max-height": typeof t.maxHeight == "number" ? `${t.maxHeight}px` : t.maxHeight
+    }));
+    return (o, d) => (l(), i(s(U), null, {
+      default: n(() => [
+        c(s(D), _({ "data-slot": "select-content" }, s(e), {
+          style: r.value,
+          class: s(m)(
+            "select-content",
+            `select-content--position-${t.position}`,
+            `select-content--size-${t.size}`,
+            t.class
+          )
+        }), {
+          default: n(() => [
+            c(te),
+            c(s(F), {
+              "data-slot": "select-viewport",
+              class: "select-viewport"
+            }, {
+              default: n(() => [
+                u(o.$slots, "default")
+              ]),
+              _: 3
+            }),
+            c(ee)
+          ]),
+          _: 3
+        }, 16, ["style", "class"])
+      ]),
+      _: 3
+    }));
+  }
+}), le = /* @__PURE__ */ f({
+  __name: "SelectGroup",
+  props: {
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(a) {
+    const t = a;
+    return (e, r) => (l(), i(s(A), _({ "data-slot": "select-group" }, t), {
+      default: n(() => [
+        u(e.$slots, "default")
+      ]),
+      _: 3
+    }, 16));
+  }
+}), ae = {
+  key: 0,
+  class: "select-item__prepend"
+}, oe = { class: "select-item__text" }, ne = {
+  key: 0,
+  class: "select-item__description"
+}, re = {
+  key: 1,
+  class: "select-item__decoration"
+}, w = /* @__PURE__ */ f({
+  __name: "SelectItem",
+  props: {
+    value: {},
+    disabled: { type: Boolean },
+    textValue: {},
+    asChild: { type: Boolean },
+    as: {},
+    class: {},
+    prepend: {},
+    description: {},
+    decoration: {}
+  },
+  emits: ["select"],
+  setup(a, { emit: t }) {
+    const e = a, o = x(e, t);
+    return (d, B) => (l(), i(s(G), _({ "data-slot": "select-item" }, s(o), {
+      class: s(m)("select-item", (e.description || d.$slots.description) && "select-item--double", e.class)
+    }), {
+      default: n(() => [
+        e.prepend || d.$slots.prepend ? (l(), g("span", ae, [
+          u(d.$slots, "prepend", {}, () => [
+            y(h(e.prepend), 1)
+          ])
+        ])) : v("", !0),
+        I("span", oe, [
+          c(s(q), { class: "select-item__label" }, {
+            default: n(() => [
+              u(d.$slots, "default")
+            ]),
+            _: 3
+          }),
+          e.description || d.$slots.description ? (l(), g("span", ne, [
+            u(d.$slots, "description", {}, () => [
+              y(h(e.description), 1)
+            ])
+          ])) : v("", !0)
+        ]),
+        e.decoration || d.$slots.decoration ? (l(), g("span", re, [
+          u(d.$slots, "decoration", {}, () => [
+            y(h(e.decoration), 1)
+          ])
+        ])) : v("", !0),
+        c(s(j), { class: "select-item__indicator" }, {
+          default: n(() => [
+            c(s(Q), {
+              class: "size-4",
+              "aria-hidden": "true"
+            })
+          ]),
+          _: 1
+        })
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+}), ie = /* @__PURE__ */ f({
+  __name: "SelectLabel",
+  props: {
+    for: {},
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(a) {
+    const t = a, e = S(t, "class");
+    return (r, o) => (l(), i(s(K), _({ "data-slot": "select-label" }, s(e), {
+      class: s(m)("select-label", t.class)
+    }), {
+      default: n(() => [
+        u(r.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+}), ce = /* @__PURE__ */ f({
+  __name: "SelectSeparator",
+  props: {
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(a) {
+    const t = a, e = S(t, "class");
+    return (r, o) => (l(), i(s(M), _({ "data-slot": "select-separator" }, s(e), {
+      class: s(m)("select-separator", t.class)
+    }), null, 16, ["class"]));
+  }
+}), de = {
+  key: 0,
+  class: "select-trigger__prepend"
+}, pe = { class: "select-trigger__value-wrap" }, ue = {
+  key: 0,
+  class: "select-trigger__label"
+}, _e = {
+  key: 1,
+  class: "select-trigger__decoration"
+}, me = /* @__PURE__ */ f({
+  __name: "SelectTrigger",
+  props: {
+    disabled: { type: Boolean },
+    reference: {},
+    asChild: { type: Boolean },
+    as: {},
+    class: {},
+    size: { default: "regular" },
+    lines: { default: "single" },
+    label: { default: void 0 },
+    prepend: { default: void 0 },
+    decoration: { default: void 0 },
+    invalid: { type: Boolean, default: !1 }
+  },
+  setup(a) {
+    const t = a, e = S(
+      t,
+      "class",
+      "size",
+      "lines",
+      "label",
+      "prepend",
+      "decoration",
+      "invalid"
+    ), r = z(() => {
+      const o = e["aria-invalid"];
+      return t.invalid || o === !0 || o === "true";
+    });
+    return (o, d) => (l(), i(s(R), _({ "data-slot": "select-trigger" }, s(e), {
+      class: s(m)(
+        "select-trigger",
+        `select-trigger--size-${t.size}`,
+        `select-trigger--lines-${t.lines}`,
+        t.class
+      ),
+      "aria-invalid": r.value ? !0 : void 0
+    }), {
+      default: n(() => [
+        t.prepend || o.$slots.prepend ? (l(), g("span", de, [
+          u(o.$slots, "prepend", {}, () => [
+            y(h(t.prepend), 1)
+          ])
+        ])) : v("", !0),
+        I("span", pe, [
+          t.label || o.$slots.label ? (l(), g("span", ue, [
+            u(o.$slots, "label", {}, () => [
+              y(h(t.label), 1)
+            ])
+          ])) : v("", !0),
+          u(o.$slots, "default")
+        ]),
+        t.decoration || o.$slots.decoration ? (l(), g("span", _e, [
+          u(o.$slots, "decoration", {}, () => [
+            y(h(t.decoration), 1)
+          ])
+        ])) : v("", !0),
+        c(s(W), null, {
+          default: n(() => [
+            c(s(E), {
+              class: "select-trigger__icon size-4",
+              "aria-hidden": "true"
+            })
+          ]),
+          _: 1
+        })
+      ]),
+      _: 3
+    }, 16, ["class", "aria-invalid"]));
+  }
+}), fe = /* @__PURE__ */ f({
+  __name: "SelectValue",
+  props: {
+    placeholder: {},
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(a) {
+    const t = a, e = S(t, "class");
+    return (r, o) => (l(), i(s(Z), _({ "data-slot": "select-value" }, s(e), {
+      class: s(m)("select-trigger__value", t.class)
+    }), null, 16, ["class"]));
+  }
+}), ge = {
+  key: 2,
+  class: "select-empty"
+}, Ce = /* @__PURE__ */ f({
+  inheritAttrs: !1,
+  __name: "KuatSelect",
+  props: {
+    open: { type: Boolean },
+    defaultOpen: { type: Boolean },
+    defaultValue: {},
+    modelValue: {},
+    by: {},
+    dir: {},
+    multiple: { type: Boolean },
+    autocomplete: {},
+    disabled: { type: Boolean },
+    name: {},
+    required: { type: Boolean },
+    class: {},
+    triggerClass: {},
+    contentClass: {},
+    items: { default: () => [] },
+    placeholder: { default: "Select an item" },
+    size: { default: "regular" },
+    lines: { default: "single" },
+    label: { default: void 0 },
+    prepend: { default: void 0 },
+    decoration: { default: void 0 },
+    invalid: { type: Boolean, default: !1 },
+    position: { default: "item-aligned" },
+    maxHeight: { default: 320 },
+    emptyText: { default: "No options available" }
+  },
+  emits: ["update:modelValue", "update:open"],
+  setup(a, { emit: t }) {
+    const e = a, r = t, o = S(
+      e,
+      "class",
+      "triggerClass",
+      "contentClass",
+      "items",
+      "placeholder",
+      "size",
+      "lines",
+      "label",
+      "prepend",
+      "decoration",
+      "invalid",
+      "position",
+      "maxHeight",
+      "emptyText"
+    ), d = T(), B = z(() => {
+      const { class: C, ...$ } = d;
+      return $;
+    });
+    return (C, $) => (l(), i(Y, _(s(o), {
+      class: s(m)(e.class),
+      "onUpdate:modelValue": $[0] || ($[0] = (p) => r("update:modelValue", p)),
+      "onUpdate:open": $[1] || ($[1] = (p) => r("update:open", p))
+    }), {
+      default: n(() => [
+        c(me, _(B.value, {
+          class: s(m)(e.triggerClass),
+          size: e.size,
+          lines: e.lines,
+          label: e.label,
+          prepend: e.prepend,
+          decoration: e.decoration,
+          invalid: e.invalid
+        }), {
+          default: n(() => [
+            c(fe, {
+              placeholder: e.placeholder
+            }, null, 8, ["placeholder"])
+          ]),
+          _: 1
+        }, 16, ["class", "size", "lines", "label", "prepend", "decoration", "invalid"]),
+        c(se, {
+          class: H(s(m)(e.contentClass)),
+          size: e.size,
+          position: e.position,
+          "max-height": e.maxHeight
+        }, {
+          default: n(() => [
+            C.$slots.default ? u(C.$slots, "default", { key: 0 }) : e.items.length > 0 ? (l(!0), g(k, { key: 1 }, P(e.items, (p, V) => (l(), g(k, {
+              key: `item-${V}`
+            }, [
+              s(X)(p) ? (l(), i(le, { key: 0 }, {
+                default: n(() => [
+                  c(ie, null, {
+                    default: n(() => [
+                      y(h(p.label), 1)
+                    ]),
+                    _: 2
+                  }, 1024),
+                  (l(!0), g(k, null, P(p.items, (b) => (l(), i(w, {
+                    key: b.value,
+                    value: b.value,
+                    disabled: b.disabled,
+                    prepend: b.prepend,
+                    description: b.description,
+                    decoration: b.decoration
+                  }, {
+                    default: n(() => [
+                      y(h(b.label), 1)
+                    ]),
+                    _: 2
+                  }, 1032, ["value", "disabled", "prepend", "description", "decoration"]))), 128)),
+                  V < e.items.length - 1 ? (l(), i(ce, { key: 0 })) : v("", !0)
+                ]),
+                _: 2
+              }, 1024)) : (l(), i(w, {
+                key: 1,
+                value: p.value,
+                disabled: p.disabled,
+                prepend: p.prepend,
+                description: p.description,
+                decoration: p.decoration
+              }, {
+                default: n(() => [
+                  y(h(p.label), 1)
+                ]),
+                _: 2
+              }, 1032, ["value", "disabled", "prepend", "description", "decoration"]))
+            ], 64))), 128)) : (l(), g("p", ge, h(e.emptyText), 1))
+          ]),
+          _: 3
+        }, 8, ["class", "size", "position", "max-height"])
+      ]),
+      _: 3
+    }, 16, ["class"]));
+  }
+});
+export {
+  Be as S,
+  Ce as _,
+  Y as a,
+  se as b,
+  le as c,
+  w as d,
+  ie as e,
+  ee as f,
+  te as g,
+  ce as h,
+  me as i,
+  fe as j,
+  $e as k
+};

package/dist/Toggle.vue_vue_type_script_setup_true_lang-CZM1GrLQ.js

@@ -0,0 +1,38 @@
+import { defineComponent as u, mergeModels as m, useModel as i, useAttrs as c, computed as g, createBlock as p, openBlock as f, unref as r, mergeProps as V, withCtx as k, renderSlot as _ } from "vue";
+import { Toggle as v } from "reka-ui";
+import { c as z } from "./utils-DLUjLwnh.js";
+import "./constants-CXAkjttx.js";
+const x = /* @__PURE__ */ u({
+  inheritAttrs: !1,
+  __name: "Toggle",
+  props: /* @__PURE__ */ m({
+    class: {},
+    size: { default: "regular" },
+    skin: { default: "outlined" }
+  }, {
+    modelValue: { type: Boolean, required: !1 },
+    modelModifiers: {}
+  }),
+  emits: ["update:modelValue"],
+  setup(o) {
+    const t = o, l = i(o, "modelValue"), a = c(), d = g(() => {
+      const { class: s, ...e } = a;
+      return e;
+    });
+    return (s, e) => (f(), p(r(v), V({
+      modelValue: l.value,
+      "onUpdate:modelValue": e[0] || (e[0] = (n) => l.value = n),
+      "data-slot": "toggle"
+    }, d.value, {
+      class: r(z)("toggle", `toggle--size-${t.size}`, `toggle--skin-${t.skin}`, t.class)
+    }), {
+      default: k(() => [
+        _(s.$slots, "default")
+      ]),
+      _: 3
+    }, 16, ["modelValue", "class"]));
+  }
+});
+export {
+  x as _
+};

package/dist/accordion.js

@@ -1,9 +1,10 @@
-import { c as r } from "./utils-DLUjLwnh.js";
-import { _ as a, b as e, A as i, a as s } from "./AccordionTrigger-BRz5PzEd.js";
+import { c as n } from "./utils-DLUjLwnh.js";
+/* empty css                */
+import { _ as i, b as t, A as e, a as s } from "./AccordionTrigger-BRz5PzEd.js";
 export {
-  a as Accordion,
-  e as AccordionContent,
-  i as AccordionItem,
+  i as Accordion,
+  t as AccordionContent,
+  e as AccordionItem,
   s as AccordionTrigger,
-  r as cn
+  n as cn
 };

package/dist/alert-dialog.js

@@ -1,14 +1,15 @@
-import { c as l } from "./utils-DLUjLwnh.js";
-import { _ as r, A as t, a as i, b as g, c as s, d as A, e as D, f as c, g as n } from "./AlertDialogTrigger.vue_vue_type_script_setup_true_lang-CK1Um8CY.js";
+import { c as o } from "./utils-DLUjLwnh.js";
+/* empty css                */
+import { _ as t, A as i, a as g, b as s, c as A, d as D, e as c, f as n, g as p } from "./AlertDialogTrigger.vue_vue_type_script_setup_true_lang-CK1Um8CY.js";
 export {
-  r as AlertDialog,
-  t as AlertDialogAction,
-  i as AlertDialogCancel,
-  g as AlertDialogContent,
-  s as AlertDialogDescription,
-  A as AlertDialogFooter,
-  D as AlertDialogHeader,
-  c as AlertDialogTitle,
-  n as AlertDialogTrigger,
-  l as cn
+  t as AlertDialog,
+  i as AlertDialogAction,
+  g as AlertDialogCancel,
+  s as AlertDialogContent,
+  A as AlertDialogDescription,
+  D as AlertDialogFooter,
+  c as AlertDialogHeader,
+  n as AlertDialogTitle,
+  p as AlertDialogTrigger,
+  o as cn
 };

package/dist/badge.js

@@ -1,7 +1,8 @@
 import { c as e } from "./utils-DLUjLwnh.js";
-import { B as s, b as t } from "./index-C3VyxnTa.js";
+/* empty css                */
+import { B as t, b as m } from "./index-C3VyxnTa.js";
 export {
-  s as Badge,
-  t as badgeVariants,
+  t as Badge,
+  m as badgeVariants,
   e as cn
 };

package/dist/button-group.js

@@ -1,9 +1,10 @@
-import { c as r } from "./utils-DLUjLwnh.js";
-import { B as u, a as p, b as n, c as s } from "./index-iz_NZI-V.js";
+import { c as a } from "./utils-DLUjLwnh.js";
+/* empty css                */
+import { B as u, a as n, b as s, c as e } from "./index-iz_NZI-V.js";
 export {
   u as ButtonGroup,
-  p as ButtonGroupSeparator,
-  n as ButtonGroupText,
-  s as buttonGroupVariants,
-  r as cn
+  n as ButtonGroupSeparator,
+  s as ButtonGroupText,
+  e as buttonGroupVariants,
+  a as cn
 };

package/dist/button.js

@@ -1,7 +1,8 @@
 import { c as a } from "./utils-DLUjLwnh.js";
-import { _ as n, b as s } from "./index-CBmjn3iX.js";
+/* empty css                */
+import { _ as s, b as m } from "./index-CBmjn3iX.js";
 export {
-  n as Button,
-  s as buttonVariants,
+  s as Button,
+  m as buttonVariants,
   a as cn
 };

package/dist/checkbox.d.ts

@@ -0,0 +1,3 @@
+export { cn } from './lib/utils';
+export { Checkbox, CheckboxField, CHECKBOX_FIELD_APPEARANCES, CHECKBOX_FIELD_LAYOUTS, } from './components/ui/checkbox';
+export type { CheckboxFieldAppearance, CheckboxFieldLayout } from './components/ui/checkbox';

package/dist/checkbox.js

@@ -0,0 +1,10 @@
+import { c as E } from "./utils-DLUjLwnh.js";
+/* empty css                */
+import { C as r, b as s, _, a as c } from "./constants-BpzIL1jq.js";
+export {
+  r as CHECKBOX_FIELD_APPEARANCES,
+  s as CHECKBOX_FIELD_LAYOUTS,
+  _ as Checkbox,
+  c as CheckboxField,
+  E as cn
+};

package/dist/components/ui/carousel/Carousel.vue.d.ts

@@ -0,0 +1,52 @@
+import { HTMLAttributes } from 'vue';
+import { CarouselApi, CarouselItemBasis, CarouselOrientation } from './context';
+
+export type CarouselEventHandler = (api: CarouselApi, eventName: string) => void;
+export type CarouselEventHandlers = Partial<Record<string, CarouselEventHandler>>;
+interface Props {
+    class?: HTMLAttributes["class"];
+    opts?: Record<string, unknown>;
+    basis?: CarouselItemBasis;
+    orientation?: CarouselOrientation;
+    plugins?: unknown[];
+    setApi?: (api: CarouselApi | undefined) => void;
+    events?: CarouselEventHandlers;
+}
+declare function __VLS_template(): {
+    controls?(_: {}): any;
+    content?(_: {}): any;
+};
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    basis: number;
+    orientation: string;
+}>>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    basis: number;
+    orientation: string;
+}>>> & Readonly<{}>, {
+    orientation: CarouselOrientation;
+    basis: CarouselItemBasis;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};