@youcan/celeste 0.6.29 → 0.6.31

package/dist/cjs/tab-menu-list.js

@@ -0,0 +1,34 @@
+"use strict";
+const Mo = require("vue");
+const useDelegatedProps = require("./use-delegated-props.js");
+const clsx = require("./chunks/clsx.js");
+const index = require("./chunks/index.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "tab-menu-list",
+  props: {
+    loop: { type: Boolean },
+    asChild: { type: Boolean },
+    as: {},
+    class: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = useDelegatedProps.useDelegatedProps(props, "class");
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(Mo.unref(index.gg), Mo.mergeProps(Mo.unref(delegatedProps), {
+        class: Mo.unref(clsx.clsx)(
+          "celeste-tab-menu-list",
+          props.class
+        )
+      }), {
+        default: Mo.withCtx(() => [
+          Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const tabMenuList = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-9877f1df"]]);
+module.exports = tabMenuList;

package/dist/cjs/tab-menu.js

@@ -0,0 +1,32 @@
+"use strict";
+const Mo = require("vue");
+const index = require("./chunks/index.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "tab-menu",
+  props: {
+    defaultValue: {},
+    orientation: {},
+    dir: {},
+    activationMode: {},
+    modelValue: {},
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const forwarded = index.xe(props, emits);
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(Mo.unref(index.yg), Mo.mergeProps(Mo.unref(forwarded), { class: "celeste-tab-menu-root" }), {
+        default: Mo.withCtx(() => [
+          Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+const tabMenu = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-b5afb6cc"]]);
+module.exports = tabMenu;

package/dist/cjs/text-input-affix.js

@@ -0,0 +1,27 @@
+"use strict";
+const Mo = require("vue");
+const useDelegatedProps = require("./use-delegated-props.js");
+const clsx = require("./chunks/clsx.js");
+;/* empty css                                                                         */
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "text-input-affix",
+  props: {
+    class: {},
+    inline: { type: Boolean },
+    asKbd: { type: Boolean }
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = useDelegatedProps.useDelegatedProps(props, "class");
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createElementBlock("span", Mo.mergeProps(Mo.unref(delegatedProps), {
+        class: Mo.unref(clsx.clsx)("celeste-text-input-affix", props.class)
+      }), [
+        Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+      ], 16);
+    };
+  }
+});
+const TextInputAffix = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-2d8a1dbc"]]);
+module.exports = TextInputAffix;

package/dist/cjs/text-input-button.js

@@ -0,0 +1,31 @@
+"use strict";
+const Mo = require("vue");
+const button = require("./button.js");
+const useDelegatedProps = require("./use-delegated-props.js");
+const clsx = require("./chunks/clsx.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "text-input-button",
+  props: {
+    inline: { type: Boolean, default: false }
+  },
+  setup(__props) {
+    const props = __props;
+    const delegatedProps = useDelegatedProps.useDelegatedProps(props, "class");
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(button, Mo.mergeProps(Mo.unref(delegatedProps), {
+        size: "sm",
+        intent: "neutral",
+        variant: "stroke",
+        class: Mo.unref(clsx.clsx)("celeste-text-input-button", props.class)
+      }), {
+        default: Mo.withCtx(() => [
+          Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+        ]),
+        _: 3
+      }, 16, ["class"]);
+    };
+  }
+});
+const TextInputButton = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-7d21364e"]]);
+module.exports = TextInputButton;

package/dist/cjs/text-input.js

@@ -0,0 +1,119 @@
+"use strict";
+const Mo = require("vue");
+const crypto = require("./crypto.js");
+const clsx = require("./chunks/clsx.js");
+const index = require("./chunks/index.js");
+const textInputButton = require("./text-input-button.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _hoisted_1 = ["for", "size", "has-error"];
+const _hoisted_2 = ["id", "type"];
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "text-input",
+  props: /* @__PURE__ */ Mo.mergeModels({
+    type: { default: "text" },
+    size: { default: "md" },
+    hasError: { type: Boolean, default: false }
+  }, {
+    "modelValue": {},
+    "modelModifiers": {}
+  }),
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const id = Mo.computed(() => props.id || crypto.uid());
+    const modelValue = Mo.useModel(__props, "modelValue");
+    const showClearButton = Mo.computed(() => {
+      return props.type === "search" && modelValue.value && String(modelValue.value).length > 0;
+    });
+    function clearInput() {
+      modelValue.value = "";
+    }
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createElementBlock("label", {
+        for: id.value,
+        size: _ctx.size,
+        role: "presentation",
+        "has-error": _ctx.hasError,
+        class: Mo.normalizeClass(Mo.unref(clsx.clsx)("celeste-text-input-wrapper", props.class))
+      }, [
+        Mo.createVNode(Mo.unref(index.O), {
+          "as-child": "",
+          class: "celeste-text-input-icon celeste-text-input-leading-icon"
+        }, {
+          default: Mo.withCtx(() => [
+            Mo.renderSlot(_ctx.$slots, "leadingIcon", {}, void 0, true)
+          ]),
+          _: 3
+        }),
+        Mo.createVNode(Mo.unref(index.O), {
+          "as-child": "",
+          class: "celeste-text-input-node celeste-text-input-leading-node"
+        }, {
+          default: Mo.withCtx(() => [
+            Mo.renderSlot(_ctx.$slots, "leadingNode", {}, void 0, true)
+          ]),
+          _: 3
+        }),
+        Mo.createVNode(Mo.unref(index.O), {
+          inline: "",
+          "as-child": "",
+          class: "celeste-text-input-inline-node celeste-text-input-leading-inline-node"
+        }, {
+          default: Mo.withCtx(() => [
+            Mo.renderSlot(_ctx.$slots, "leadingInlineNode", {}, void 0, true)
+          ]),
+          _: 3
+        }),
+        Mo.withDirectives(Mo.createElementVNode("input", Mo.mergeProps({
+          id: id.value,
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => modelValue.value = $event)
+        }, _ctx.$attrs, {
+          type: _ctx.type,
+          class: "celeste-text-input"
+        }), null, 16, _hoisted_2), [
+          [Mo.vModelDynamic, modelValue.value]
+        ]),
+        Mo.createVNode(Mo.unref(index.O), {
+          "as-child": "",
+          class: "celeste-text-input-icon celeste-text-input-trailing-icon"
+        }, {
+          default: Mo.withCtx(() => [
+            Mo.renderSlot(_ctx.$slots, "trailingIcon", {}, void 0, true)
+          ]),
+          _: 3
+        }),
+        Mo.createVNode(Mo.unref(index.O), {
+          "as-child": "",
+          class: "celeste-text-input-node celeste-text-input-trailing-node"
+        }, {
+          default: Mo.withCtx(() => [
+            Mo.renderSlot(_ctx.$slots, "trailingNode", {}, void 0, true)
+          ]),
+          _: 3
+        }),
+        Mo.createVNode(Mo.unref(index.O), {
+          inline: "",
+          "as-child": "",
+          class: "celeste-text-input-inline-node celeste-text-input-trailing-inline-node"
+        }, {
+          default: Mo.withCtx(() => [
+            showClearButton.value ? (Mo.openBlock(), Mo.createBlock(textInputButton, {
+              key: 0,
+              type: "button",
+              "aria-label": "Clear search",
+              onClick: clearInput
+            }, {
+              default: Mo.withCtx(() => _cache[1] || (_cache[1] = [
+                Mo.createElementVNode("i", { class: "i-celeste-close-line" }, null, -1)
+              ])),
+              _: 1
+            })) : Mo.renderSlot(_ctx.$slots, "trailingInlineNode", { key: 1 }, void 0, true)
+          ]),
+          _: 3
+        })
+      ], 10, _hoisted_1);
+    };
+  }
+});
+const TextInput = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-a368a0c2"]]);
+module.exports = TextInput;

package/dist/cjs/textarea.js

@@ -0,0 +1,56 @@
+"use strict";
+const Mo = require("vue");
+const clsx = require("./chunks/clsx.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _hoisted_1 = ["aria-disabled"];
+const _hoisted_2 = ["placeholder", "maxlength", "disabled"];
+const _hoisted_3 = {
+  key: 0,
+  class: "celeste-textarea-count"
+};
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "textarea",
+  props: /* @__PURE__ */ Mo.mergeModels({
+    class: {},
+    placeholder: { default: "Placeholder" },
+    showCount: { type: Boolean, default: true },
+    disabled: { type: Boolean, default: false },
+    maxLength: {}
+  }, {
+    "modelValue": {},
+    "modelModifiers": {}
+  }),
+  emits: ["update:modelValue"],
+  setup(__props) {
+    const props = __props;
+    const modelValue = Mo.useModel(__props, "modelValue");
+    return (_ctx, _cache) => {
+      var _a;
+      return Mo.openBlock(), Mo.createElementBlock("div", {
+        class: Mo.normalizeClass(Mo.unref(clsx.clsx)(
+          "celeste-textarea-wrapper",
+          props.class
+        )),
+        "aria-disabled": _ctx.disabled,
+        onClick: _cache[1] || (_cache[1] = ($event) => {
+          var _a2;
+          return (_a2 = _ctx.$el.querySelector("textarea")) == null ? void 0 : _a2.focus();
+        })
+      }, [
+        Mo.withDirectives(Mo.createElementVNode("textarea", Mo.mergeProps({
+          "onUpdate:modelValue": _cache[0] || (_cache[0] = ($event) => modelValue.value = $event)
+        }, _ctx.$attrs, {
+          placeholder: _ctx.placeholder,
+          maxlength: _ctx.maxLength,
+          disabled: _ctx.disabled,
+          class: "celeste-textarea"
+        }), null, 16, _hoisted_2), [
+          [Mo.vModelText, modelValue.value]
+        ]),
+        _ctx.showCount && Number(_ctx.maxLength) ? (Mo.openBlock(), Mo.createElementBlock("span", _hoisted_3, Mo.toDisplayString(`${((_a = modelValue.value) == null ? void 0 : _a.length) || 0}/${_ctx.maxLength}`), 1)) : Mo.createCommentVNode("", true)
+      ], 10, _hoisted_1);
+    };
+  }
+});
+const textarea = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-76864cee"]]);
+module.exports = textarea;

package/dist/cjs/tooltip.js

@@ -0,0 +1,115 @@
+"use strict";
+const Mo = require("vue");
+const compactButton = require("./compact-button.js");
+const clsx = require("./chunks/clsx.js");
+const index = require("./chunks/index.js");
+const _pluginVue_exportHelper = require("./chunks/_plugin-vue_export-helper.js");
+const _hoisted_1 = { class: "celeste-tooltip-content-box" };
+const _hoisted_2 = {
+  key: 0,
+  class: "celeste-tooltip-content-title"
+};
+const _hoisted_3 = {
+  key: 1,
+  class: "celeste-tooltip-content-description"
+};
+const _sfc_main = /* @__PURE__ */ Mo.defineComponent({
+  __name: "tooltip",
+  props: {
+    class: {},
+    size: { default: "sm" },
+    variant: { default: "light" },
+    icon: {},
+    title: {},
+    description: {},
+    dismissible: { type: Boolean },
+    defaultOpen: { type: Boolean },
+    open: { type: Boolean },
+    delayDuration: { default: 0 },
+    disableHoverableContent: { type: Boolean },
+    disableClosingTrigger: { type: Boolean },
+    disabled: { type: Boolean },
+    ignoreNonKeyboardFocus: { type: Boolean },
+    forceMount: { type: Boolean },
+    ariaLabel: {},
+    asChild: { type: Boolean },
+    as: {},
+    side: {},
+    sideOffset: { default: 12 },
+    align: {},
+    alignOffset: {},
+    avoidCollisions: { type: Boolean },
+    collisionBoundary: {},
+    collisionPadding: {},
+    arrowPadding: {},
+    sticky: {},
+    hideWhenDetached: { type: Boolean }
+  },
+  emits: ["update:open"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const forwarded = index.xe(props, emits);
+    const isOpen = Mo.ref(props.defaultOpen);
+    function close() {
+      isOpen.value = false;
+    }
+    return (_ctx, _cache) => {
+      return Mo.openBlock(), Mo.createBlock(Mo.unref(index.Lg), null, {
+        default: Mo.withCtx(() => [
+          Mo.createVNode(Mo.unref(index.zg), Mo.mergeProps(Mo.unref(forwarded), {
+            open: props.open || isOpen.value,
+            "onUpdate:open": _cache[0] || (_cache[0] = (state) => isOpen.value = state)
+          }), {
+            default: Mo.withCtx(() => [
+              Mo.createVNode(Mo.unref(index.Kg), { "as-child": "" }, {
+                default: Mo.withCtx(() => [
+                  Mo.renderSlot(_ctx.$slots, "default", {}, void 0, true)
+                ]),
+                _: 3
+              }),
+              Mo.createVNode(Mo.unref(index.jg), { class: "celeste-tooltip-portal" }, {
+                default: Mo.withCtx(() => [
+                  Mo.createVNode(Mo.unref(index.Hg), Mo.mergeProps({ ...Mo.unref(forwarded), ..._ctx.$attrs }, {
+                    size: _ctx.size,
+                    variant: _ctx.variant,
+                    class: Mo.unref(clsx.clsx)("celeste-tooltip-content", props.class)
+                  }), {
+                    default: Mo.withCtx(() => [
+                      _ctx.icon ? (Mo.openBlock(), Mo.createElementBlock("i", {
+                        key: 0,
+                        class: Mo.normalizeClass(`celeste-tooltip-content-icon ${_ctx.icon}`)
+                      }, null, 2)) : Mo.createCommentVNode("", true),
+                      Mo.createElementVNode("div", _hoisted_1, [
+                        _ctx.title ? (Mo.openBlock(), Mo.createElementBlock("span", _hoisted_2, Mo.toDisplayString(_ctx.title), 1)) : Mo.createCommentVNode("", true),
+                        _ctx.description ? (Mo.openBlock(), Mo.createElementBlock("span", _hoisted_3, Mo.toDisplayString(_ctx.description), 1)) : Mo.createCommentVNode("", true)
+                      ]),
+                      _ctx.dismissible ? (Mo.openBlock(), Mo.createBlock(compactButton, {
+                        key: 1,
+                        variant: "ghost",
+                        icon: "i-celeste-close-line",
+                        onClick: close
+                      })) : Mo.createCommentVNode("", true),
+                      Mo.createVNode(Mo.unref(index.Wg), { "as-child": "" }, {
+                        default: Mo.withCtx(() => _cache[1] || (_cache[1] = [
+                          Mo.createElementVNode("span", { class: "celeste-tooltip-content-arrow" }, null, -1)
+                        ])),
+                        _: 1
+                      })
+                    ]),
+                    _: 1
+                  }, 16, ["size", "variant", "class"])
+                ]),
+                _: 1
+              })
+            ]),
+            _: 3
+          }, 16, ["open"])
+        ]),
+        _: 3
+      });
+    };
+  }
+});
+const Tooltip = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["__scopeId", "data-v-0dc4a40e"]]);
+module.exports = Tooltip;

package/dist/cjs/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/use-color-model.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const useColorModel = require("./chunks/use-color-model.js");
+require("vue");
+exports.ColorPickerEmits = useColorModel.ColorPickerEmits;
+exports.defineColorModel = useColorModel.defineColorModel;

package/dist/cjs/use-delegated-props.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Mo = require("vue");
+function useDelegatedProps(props, excludeKeys = ["class"]) {
+  return Mo.computed(() => {
+    const keysToExclude = Array.isArray(excludeKeys) ? excludeKeys : [excludeKeys];
+    const delegated = { ...props };
+    keysToExclude.forEach((key) => {
+      delete delegated[key];
+    });
+    return delegated;
+  });
+}
+exports.useDelegatedProps = useDelegatedProps;

package/dist/cjs/use-user-select.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Mo = require("vue");
+function useUserPageSelection() {
+  const isDisabled = Mo.ref(false);
+  let styleElement = null;
+  const preventPageUserSelect = () => {
+    if (!styleElement) {
+      styleElement = document.createElement("style");
+      styleElement.textContent = "body > * { user-select: none; }";
+      document.head.appendChild(styleElement);
+      isDisabled.value = true;
+    }
+  };
+  const allowPageUserSelect = () => {
+    if (styleElement) {
+      styleElement.remove();
+      styleElement = null;
+      isDisabled.value = false;
+    }
+  };
+  const togglePageUserSelect = () => {
+    if (styleElement) {
+      allowPageUserSelect();
+      return;
+    }
+    preventPageUserSelect();
+  };
+  Mo.onUnmounted(() => {
+    allowPageUserSelect();
+  });
+  return {
+    isDisabled: Mo.readonly(isDisabled),
+    togglePageUserSelect,
+    preventPageUserSelect,
+    allowPageUserSelect
+  };
+}
+exports.useUserPageSelection = useUserPageSelection;

package/dist/components/alert/alert.d.ts

@@ -0,0 +1,30 @@
+import { HTMLAttributes } from 'vue';
+export interface AlertProps {
+    class?: HTMLAttributes['class'];
+    size?: 'xs' | 'sm' | 'lg';
+    variant?: 'fill' | 'light' | 'lighter' | 'stroke';
+    state?: 'information' | 'success' | 'warning' | 'error' | 'feature';
+    dismissable?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<AlertProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    dismiss: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<AlertProps> & Readonly<{
+    onDismiss?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: "xs" | "sm" | "lg";
+    variant: "fill" | "light" | "lighter" | "stroke";
+    state: "information" | "success" | "warning" | "error" | "feature";
+    dismissable: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>, {
+    default?(_: {}): any;
+    title?(_: {}): any;
+    description?(_: {}): any;
+    primary?(_: {}): any;
+    secondary?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/alert/index.d.ts

@@ -0,0 +1,2 @@
+export * from './alert';
+export { default as Alert } from './alert';

package/dist/components/badge/badge.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes } from 'vue';
+export interface BadgeProps {
+    size?: 'sm' | 'md';
+    variant?: 'fill' | 'light' | 'lighter' | 'stroke';
+    type?: 'basic' | 'dot' | 'leading-icon' | 'trailing-icon';
+    state?: 'faded' | 'information' | 'warning' | 'error' | 'success' | 'away' | 'feature' | 'verified' | 'highlighted' | 'stable';
+    disabled?: boolean;
+    icon?: string;
+    label?: string;
+    class?: HTMLAttributes['class'];
+}
+declare const _default: import('vue').DefineComponent<BadgeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BadgeProps> & Readonly<{}>, {
+    size: "sm" | "md";
+    variant: "fill" | "light" | "lighter" | "stroke";
+    type: "basic" | "dot" | "leading-icon" | "trailing-icon";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/badge/index.d.ts

@@ -0,0 +1,4 @@
+export * from './badge';
+export { default as Badge } from './badge';
+export * from './status-badge';
+export { default as StatusBadge } from './status-badge';

package/dist/components/badge/status-badge.d.ts

@@ -0,0 +1,13 @@
+import { HTMLAttributes } from 'vue';
+export interface StatusBadgeProps {
+    variant?: 'stroke' | 'light';
+    dotted?: boolean;
+    state?: 'success' | 'warning' | 'error' | 'faded';
+    label: string;
+    class?: HTMLAttributes['class'];
+}
+declare const _default: import('vue').DefineComponent<StatusBadgeProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<StatusBadgeProps> & Readonly<{}>, {
+    variant: "stroke" | "light";
+    state: "success" | "warning" | "error" | "faded";
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/button/button.d.ts

@@ -0,0 +1,22 @@
+import { HTMLAttributes } from 'vue';
+import { PrimitiveProps } from 'radix-vue';
+export interface ButtonProps extends PrimitiveProps {
+    class?: HTMLAttributes['class'];
+    size?: 'xxs' | 'xs' | 'sm' | 'md';
+    intent?: 'primary' | 'neutral' | 'error';
+    variant?: 'fill' | 'stroke' | 'lighter' | 'ghost';
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<ButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ButtonProps> & Readonly<{}>, {
+    size: "xxs" | "xs" | "sm" | "md";
+    variant: "fill" | "stroke" | "lighter" | "ghost";
+    intent: "primary" | "neutral" | "error";
+    as: import('radix-vue').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/button/compact-button.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes } from 'vue';
+import { PrimitiveProps } from 'radix-vue';
+export interface CompactButtonProps extends PrimitiveProps {
+    class?: HTMLAttributes['class'];
+    icon: string;
+    size?: 'lg' | 'md';
+    rounded?: boolean;
+    variant?: 'stroke' | 'white' | 'ghost';
+}
+declare const _default: import('vue').DefineComponent<CompactButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CompactButtonProps> & Readonly<{}>, {
+    size: "lg" | "md";
+    variant: "stroke" | "white" | "ghost";
+    as: import('radix-vue').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/button/fancy-button.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes } from 'vue';
+import { PrimitiveProps } from 'radix-vue';
+export interface FancyButtonProps extends PrimitiveProps {
+    class?: HTMLAttributes['class'];
+    size?: 'xs' | 'sm' | 'md';
+    intent?: 'primary' | 'neutral' | 'error' | 'basic';
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<FancyButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FancyButtonProps> & Readonly<{}>, {
+    size: "xs" | "sm" | "md";
+    intent: "primary" | "neutral" | "error" | "basic";
+    as: import('radix-vue').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/button/index.d.ts

@@ -0,0 +1,10 @@
+export * from './button';
+export { default as Button } from './button';
+export * from './compact-button';
+export { default as CompactButton } from './compact-button';
+export * from './fancy-button';
+export { default as FancyButton } from './fancy-button';
+export * from './link-button';
+export { default as LinkButton } from './link-button';
+export * from './social-button';
+export { default as SocialButton } from './social-button';

package/dist/components/button/link-button.d.ts

@@ -0,0 +1,22 @@
+import { HTMLAttributes } from 'vue';
+import { PrimitiveProps } from 'radix-vue';
+export interface LinkButtonProps extends PrimitiveProps {
+    class?: HTMLAttributes['class'];
+    size?: 'sm' | 'md';
+    intent?: 'primary' | 'black' | 'gray' | 'error';
+    underline?: boolean;
+    disabled?: boolean;
+}
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<LinkButtonProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<LinkButtonProps> & Readonly<{}>, {
+    size: "sm" | "md";
+    intent: "primary" | "black" | "gray" | "error";
+    as: import('radix-vue').AsTag | import('vue').Component;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};