abckit 0.0.1

package/dist/runtime/components/ui/timezone-select/useTimezone.js

@@ -0,0 +1,224 @@
+export function useTimezone(labels = {}) {
+  const popularTimezones = [
+    "UTC",
+    "Europe/Istanbul",
+    "Europe/London",
+    "Europe/Berlin",
+    "America/New_York",
+    "America/Los_Angeles",
+    "America/Chicago",
+    "Asia/Tokyo",
+    "Asia/Shanghai",
+    "Australia/Sydney",
+    "Asia/Dubai",
+    "Asia/Kolkata"
+  ];
+  const countryMapping = {
+    "Europe/Istanbul": "Turkey",
+    "Europe/London": "United Kingdom",
+    "Europe/Berlin": "Germany",
+    "Europe/Paris": "France",
+    "Europe/Rome": "Italy",
+    "Europe/Madrid": "Spain",
+    "Europe/Amsterdam": "Netherlands",
+    "Europe/Vienna": "Austria",
+    "Europe/Warsaw": "Poland",
+    "Europe/Prague": "Czech Republic",
+    "Europe/Budapest": "Hungary",
+    "Europe/Stockholm": "Sweden",
+    "Europe/Oslo": "Norway",
+    "Europe/Copenhagen": "Denmark",
+    "Europe/Helsinki": "Finland",
+    "Europe/Athens": "Greece",
+    "Europe/Zurich": "Switzerland",
+    "America/New_York": "United States (Eastern)",
+    "America/Los_Angeles": "United States (Pacific)",
+    "America/Chicago": "United States (Central)",
+    "America/Denver": "United States (Mountain)",
+    "America/Toronto": "Canada",
+    "America/Sao_Paulo": "Brazil",
+    "America/Argentina/Buenos_Aires": "Argentina",
+    "America/Mexico_City": "Mexico",
+    "Asia/Tokyo": "Japan",
+    "Asia/Shanghai": "China",
+    "Asia/Hong_Kong": "Hong Kong",
+    "Asia/Singapore": "Singapore",
+    "Asia/Dubai": "United Arab Emirates",
+    "Asia/Kolkata": "India",
+    "Asia/Seoul": "South Korea",
+    "Asia/Bangkok": "Thailand",
+    "Asia/Jakarta": "Indonesia",
+    "Australia/Sydney": "Australia",
+    "Africa/Cairo": "Egypt",
+    "Africa/Lagos": "Nigeria",
+    "Africa/Johannesburg": "South Africa"
+  };
+  const regionLabels = {
+    "UTC": "UTC",
+    "Europe": "Europe",
+    "America": "America",
+    "Asia": "Asia",
+    "Africa": "Africa",
+    "Australia": "Australia/Oceania",
+    "Pacific": "Pacific",
+    "Atlantic": "Atlantic",
+    "Indian": "Indian Ocean",
+    "Antarctica": "Antarctica"
+  };
+  const getTimezoneOffset = (timezone) => {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const utc = now.getTime() + now.getTimezoneOffset() * 6e4;
+      const targetTime = new Date(utc + getTimezoneOffsetMinutes(timezone) * 6e4);
+      const formatter = new Intl.DateTimeFormat("en", {
+        timeZone: timezone,
+        timeZoneName: "longOffset"
+      });
+      const parts = formatter.formatToParts(now);
+      const offsetPart = parts.find((part) => part.type === "timeZoneName");
+      if (offsetPart?.value && offsetPart.value !== timezone) {
+        return offsetPart.value.replace("GMT", "UTC");
+      }
+      const offset = getTimezoneOffsetMinutes(timezone);
+      const hours = Math.floor(Math.abs(offset) / 60);
+      const minutes = Math.abs(offset) % 60;
+      const sign = offset >= 0 ? "+" : "-";
+      return `UTC${sign}${hours.toString().padStart(2, "0")}:${minutes.toString().padStart(2, "0")}`;
+    } catch {
+      return "UTC+00:00";
+    }
+  };
+  const getTimezoneOffsetMinutes = (timezone) => {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const utcTime = new Date(now.toLocaleString("en-US", { timeZone: "UTC" }));
+      const targetTime = new Date(now.toLocaleString("en-US", { timeZone: timezone }));
+      return (targetTime.getTime() - utcTime.getTime()) / (1e3 * 60);
+    } catch {
+      return 0;
+    }
+  };
+  const formatTimezoneLabel = (timezone) => {
+    if (timezone === "UTC") return "UTC";
+    const parts = timezone.split("/");
+    if (parts.length < 2) return timezone;
+    const city = parts[parts.length - 1].replace(/_/g, " ");
+    return city;
+  };
+  const getCurrentTimezone = () => {
+    try {
+      return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    } catch {
+      return "UTC";
+    }
+  };
+  const getAllTimezones = () => {
+    try {
+      const timezones = Intl.supportedValuesOf("timeZone");
+      return timezones.map((timezone) => {
+        const region = timezone === "UTC" ? "UTC" : timezone.split("/")[0];
+        const label = formatTimezoneLabel(timezone);
+        const offset = getTimezoneOffset(timezone);
+        const country = countryMapping[timezone];
+        const popular = popularTimezones.includes(timezone);
+        const searchText = [
+          timezone,
+          label,
+          offset,
+          country,
+          regionLabels[region]
+        ].filter(Boolean).join(" ").toLowerCase();
+        return {
+          value: timezone,
+          label,
+          offset,
+          region,
+          country,
+          popular,
+          searchText
+        };
+      }).sort((a, b) => {
+        if (a.popular && !b.popular) return -1;
+        if (!a.popular && b.popular) return 1;
+        if (a.region !== b.region) return a.region.localeCompare(b.region);
+        return a.label.localeCompare(b.label);
+      });
+    } catch {
+      return [
+        { value: "UTC", label: "UTC", offset: "UTC+00:00", region: "UTC", popular: true, searchText: "utc" },
+        { value: "Europe/Istanbul", label: "Istanbul", offset: "UTC+03:00", region: "Europe", country: "T\xFCrkiye", popular: true, searchText: "europe/istanbul istanbul t\xFCrkiye utc+03:00 avrupa" }
+      ];
+    }
+  };
+  const getTimezoneGroups = () => {
+    const timezones = getAllTimezones();
+    const groups = /* @__PURE__ */ new Map();
+    timezones.forEach((tz) => {
+      if (!groups.has(tz.region)) {
+        groups.set(tz.region, []);
+      }
+      groups.get(tz.region).push(tz);
+    });
+    const result = [];
+    const popularTzs = timezones.filter((tz) => tz.popular);
+    if (popularTzs.length > 0) {
+      result.push({
+        region: "popular",
+        label: labels.popularTimezones || "Popular Timezones",
+        timezones: popularTzs
+      });
+    }
+    const regionOrder = ["UTC", "Europe", "Asia", "America", "Africa", "Australia", "Pacific", "Atlantic", "Indian", "Antarctica"];
+    regionOrder.forEach((region) => {
+      const regionTzs = groups.get(region)?.filter((tz) => !tz.popular);
+      if (regionTzs && regionTzs.length > 0) {
+        result.push({
+          region,
+          label: regionLabels[region] || region,
+          timezones: regionTzs
+        });
+      }
+    });
+    groups.forEach((timezones2, region) => {
+      if (!regionOrder.includes(region)) {
+        const regionTzs = timezones2.filter((tz) => !tz.popular);
+        if (regionTzs.length > 0) {
+          result.push({
+            region,
+            label: regionLabels[region] || region,
+            timezones: regionTzs
+          });
+        }
+      }
+    });
+    return result;
+  };
+  const searchTimezones = (query, limit = 50) => {
+    if (!query.trim()) {
+      return getAllTimezones().slice(0, limit);
+    }
+    const searchTerm = query.toLowerCase();
+    const allTimezones = getAllTimezones();
+    const filtered = allTimezones.filter((tz) => tz.searchText.includes(searchTerm));
+    return filtered.slice(0, limit);
+  };
+  const getTimezoneDisplayText = (timezone) => {
+    const tz = getAllTimezones().find((t) => t.value === timezone);
+    if (!tz) return timezone;
+    if (timezone === "UTC") return "UTC (GMT+00:00)";
+    const parts = [tz.label, `(${tz.offset})`];
+    if (tz.country) parts.splice(1, 0, `-`, tz.country);
+    return parts.join(" ");
+  };
+  return {
+    getAllTimezones,
+    getTimezoneGroups,
+    searchTimezones,
+    getCurrentTimezone,
+    getTimezoneOffset,
+    getTimezoneDisplayText,
+    formatTimezoneLabel,
+    popularTimezones,
+    regionLabels
+  };
+}

package/dist/runtime/components/ui/toggle/Toggle.d.vue.ts

@@ -0,0 +1,30 @@
+import type { ToggleProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import type { ToggleVariants } from ".";
+type __VLS_Props = ToggleProps & {
+    class?: HTMLAttributes["class"];
+    variant?: ToggleVariants["variant"];
+    size?: ToggleVariants["size"];
+};
+declare var __VLS_8: {
+    modelValue: boolean;
+    state: "on" | "off";
+    pressed: boolean;
+    disabled: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/toggle/Toggle.vue

@@ -0,0 +1,32 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { Toggle, useForwardPropsEmits } from "reka-ui";
+import { cn } from "abckit/utils";
+import { toggleVariants } from ".";
+const props = defineProps({
+  defaultValue: { type: Boolean, required: false },
+  modelValue: { type: [Boolean, null], required: false },
+  disabled: { type: Boolean, required: false, default: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  name: { type: String, required: false },
+  required: { type: Boolean, required: false },
+  class: { type: null, required: false },
+  variant: { type: null, required: false, default: "default" },
+  size: { type: null, required: false, default: "default" }
+});
+const emits = defineEmits(["update:modelValue"]);
+const delegatedProps = reactiveOmit(props, "class", "size", "variant");
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <Toggle
+    v-slot="slotProps"
+    data-slot="toggle"
+    v-bind="forwarded"
+    :class="cn(toggleVariants({ variant, size }), props.class)"
+  >
+    <slot v-bind="slotProps" />
+  </Toggle>
+</template>

package/dist/runtime/components/ui/toggle/Toggle.vue.d.ts

@@ -0,0 +1,30 @@
+import type { ToggleProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import type { ToggleVariants } from ".";
+type __VLS_Props = ToggleProps & {
+    class?: HTMLAttributes["class"];
+    variant?: ToggleVariants["variant"];
+    size?: ToggleVariants["size"];
+};
+declare var __VLS_8: {
+    modelValue: boolean;
+    state: "on" | "off";
+    pressed: boolean;
+    disabled: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/toggle/index.d.ts

@@ -0,0 +1,7 @@
+import type { VariantProps } from "class-variance-authority";
+export { default as Toggle } from "./Toggle.vue.js";
+export declare const toggleVariants: (props?: ({
+    variant?: "default" | "outline" | null | undefined;
+    size?: "lg" | "default" | "sm" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export type ToggleVariants = VariantProps<typeof toggleVariants>;

package/dist/runtime/components/ui/toggle/index.js

@@ -0,0 +1,22 @@
+import { cva } from "class-variance-authority";
+export { default as Toggle } from "./Toggle.vue";
+export const toggleVariants = cva(
+  "inline-flex items-center justify-center gap-2 rounded-md text-sm font-medium hover:bg-muted hover:text-muted-foreground disabled:pointer-events-none disabled:opacity-50 data-[state=on]:bg-accent data-[state=on]:text-accent-foreground [&_svg]:pointer-events-none [&_svg:not([class*='size-'])]:size-4 [&_svg]:shrink-0 focus-visible:border-ring focus-visible:ring-ring/50 focus-visible:ring-[3px] outline-none transition-[color,box-shadow] aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive whitespace-nowrap",
+  {
+    variants: {
+      variant: {
+        default: "bg-transparent",
+        outline: "border border-input bg-transparent shadow-xs hover:bg-accent hover:text-accent-foreground"
+      },
+      size: {
+        default: "h-9 px-2 min-w-9",
+        sm: "h-8 px-1.5 min-w-8",
+        lg: "h-10 px-2.5 min-w-10"
+      }
+    },
+    defaultVariants: {
+      variant: "default",
+      size: "default"
+    }
+  }
+);

package/dist/runtime/components/ui/toggle-group/ToggleGroup.d.vue.ts

@@ -0,0 +1,30 @@
+import type { VariantProps } from "class-variance-authority";
+import type { ToggleGroupRootProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import type { toggleVariants } from 'abckit/shadcn/toggle';
+type ToggleGroupVariants = VariantProps<typeof toggleVariants>;
+type __VLS_Props = ToggleGroupRootProps & {
+    class?: HTMLAttributes["class"];
+    variant?: ToggleGroupVariants["variant"];
+    size?: ToggleGroupVariants["size"];
+    spacing?: number;
+};
+declare var __VLS_8: {
+    modelValue: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[] | undefined;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (payload: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((payload: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/toggle-group/ToggleGroup.vue

@@ -0,0 +1,49 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { ToggleGroupRoot, useForwardPropsEmits } from "reka-ui";
+import { provide } from "vue";
+import { cn } from "abckit/utils";
+const props = defineProps({
+  rovingFocus: { type: Boolean, required: false },
+  disabled: { type: Boolean, required: false },
+  orientation: { type: String, required: false },
+  dir: { type: String, required: false },
+  loop: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  name: { type: String, required: false },
+  required: { type: Boolean, required: false },
+  type: { type: String, required: false },
+  modelValue: { type: null, required: false },
+  defaultValue: { type: null, required: false },
+  class: { type: null, required: false },
+  variant: { type: null, required: false },
+  size: { type: null, required: false },
+  spacing: { type: Number, required: false, default: 0 }
+});
+const emits = defineEmits(["update:modelValue"]);
+provide("toggleGroup", {
+  variant: props.variant,
+  size: props.size,
+  spacing: props.spacing
+});
+const delegatedProps = reactiveOmit(props, "class", "size", "variant");
+const forwarded = useForwardPropsEmits(delegatedProps, emits);
+</script>
+
+<template>
+  <ToggleGroupRoot
+    v-slot="slotProps"
+    data-slot="toggle-group"
+    :data-size="size"
+    :data-variant="variant"
+    :data-spacing="spacing"
+    :style="{
+  '--gap': spacing
+}"
+    v-bind="forwarded"
+    :class="cn('group/toggle-group flex w-fit items-center gap-[--spacing(var(--gap))] rounded-md data-[spacing=default]:data-[variant=outline]:shadow-xs', props.class)"
+  >
+    <slot v-bind="slotProps" />
+  </ToggleGroupRoot>
+</template>

package/dist/runtime/components/ui/toggle-group/ToggleGroup.vue.d.ts

@@ -0,0 +1,30 @@
+import type { VariantProps } from "class-variance-authority";
+import type { ToggleGroupRootProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import type { toggleVariants } from 'abckit/shadcn/toggle';
+type ToggleGroupVariants = VariantProps<typeof toggleVariants>;
+type __VLS_Props = ToggleGroupRootProps & {
+    class?: HTMLAttributes["class"];
+    variant?: ToggleGroupVariants["variant"];
+    size?: ToggleGroupVariants["size"];
+    spacing?: number;
+};
+declare var __VLS_8: {
+    modelValue: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[] | undefined;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (payload: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((payload: import("reka-ui").AcceptableValue | import("reka-ui").AcceptableValue[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/toggle-group/ToggleGroupItem.d.vue.ts

@@ -0,0 +1,30 @@
+import type { VariantProps } from "class-variance-authority";
+import type { ToggleGroupItemProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { toggleVariants } from 'abckit/shadcn/toggle';
+type ToggleGroupVariants = VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+};
+type __VLS_Props = ToggleGroupItemProps & {
+    class?: HTMLAttributes["class"];
+    variant?: ToggleGroupVariants["variant"];
+    size?: ToggleGroupVariants["size"];
+};
+declare var __VLS_8: {
+    modelValue: boolean;
+    state: "on" | "off";
+    pressed: boolean;
+    disabled: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/toggle-group/ToggleGroupItem.vue

@@ -0,0 +1,41 @@
+<script setup>
+import { reactiveOmit } from "@vueuse/core";
+import { ToggleGroupItem, useForwardProps } from "reka-ui";
+import { inject } from "vue";
+import { cn } from "abckit/utils";
+import { toggleVariants } from "abckit/shadcn/toggle";
+const props = defineProps({
+  value: { type: null, required: true },
+  disabled: { type: Boolean, required: false },
+  asChild: { type: Boolean, required: false },
+  as: { type: null, required: false },
+  class: { type: null, required: false },
+  variant: { type: null, required: false },
+  size: { type: null, required: false }
+});
+const context = inject("toggleGroup");
+const delegatedProps = reactiveOmit(props, "class", "size", "variant");
+const forwardedProps = useForwardProps(delegatedProps);
+</script>
+
+<template>
+  <ToggleGroupItem
+    v-slot="slotProps"
+    data-slot="toggle-group-item"
+    :data-variant="context?.variant || variant"
+    :data-size="context?.size || size"
+    :data-spacing="context?.spacing"
+    v-bind="forwardedProps"
+    :class="cn(
+  toggleVariants({
+    variant: context?.variant || variant,
+    size: context?.size || size
+  }),
+  'w-auto min-w-0 shrink-0 px-3 focus:z-10 focus-visible:z-10',
+  'data-[spacing=0]:rounded-none data-[spacing=0]:shadow-none data-[spacing=0]:first:rounded-l-md data-[spacing=0]:last:rounded-r-md data-[spacing=0]:data-[variant=outline]:border-l-0 data-[spacing=0]:data-[variant=outline]:first:border-l',
+  props.class
+)"
+  >
+    <slot v-bind="slotProps" />
+  </ToggleGroupItem>
+</template>

package/dist/runtime/components/ui/toggle-group/ToggleGroupItem.vue.d.ts

@@ -0,0 +1,30 @@
+import type { VariantProps } from "class-variance-authority";
+import type { ToggleGroupItemProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+import { toggleVariants } from 'abckit/shadcn/toggle';
+type ToggleGroupVariants = VariantProps<typeof toggleVariants> & {
+    spacing?: number;
+};
+type __VLS_Props = ToggleGroupItemProps & {
+    class?: HTMLAttributes["class"];
+    variant?: ToggleGroupVariants["variant"];
+    size?: ToggleGroupVariants["size"];
+};
+declare var __VLS_8: {
+    modelValue: boolean;
+    state: "on" | "off";
+    pressed: boolean;
+    disabled: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/toggle-group/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ToggleGroup } from "./ToggleGroup.vue.js";
+export { default as ToggleGroupItem } from "./ToggleGroupItem.vue.js";

package/dist/runtime/components/ui/toggle-group/index.js

@@ -0,0 +1,2 @@
+export { default as ToggleGroup } from "./ToggleGroup.vue";
+export { default as ToggleGroupItem } from "./ToggleGroupItem.vue";

package/dist/runtime/components/ui/tooltip/Tooltip.d.vue.ts

@@ -0,0 +1,20 @@
+import type { TooltipRootProps } from "reka-ui";
+declare var __VLS_8: {
+    open: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<TooltipRootProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<TooltipRootProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/tooltip/Tooltip.vue

@@ -0,0 +1,24 @@
+<script setup>
+import { TooltipRoot, useForwardPropsEmits } from "reka-ui";
+const props = defineProps({
+  defaultOpen: { type: Boolean, required: false },
+  open: { type: Boolean, required: false },
+  delayDuration: { type: Number, required: false },
+  disableHoverableContent: { type: Boolean, required: false },
+  disableClosingTrigger: { type: Boolean, required: false },
+  disabled: { type: Boolean, required: false },
+  ignoreNonKeyboardFocus: { type: Boolean, required: false }
+});
+const emits = defineEmits(["update:open"]);
+const forwarded = useForwardPropsEmits(props, emits);
+</script>
+
+<template>
+  <TooltipRoot
+    v-slot="slotProps"
+    data-slot="tooltip"
+    v-bind="forwarded"
+  >
+    <slot v-bind="slotProps" />
+  </TooltipRoot>
+</template>

package/dist/runtime/components/ui/tooltip/Tooltip.vue.d.ts

@@ -0,0 +1,20 @@
+import type { TooltipRootProps } from "reka-ui";
+declare var __VLS_8: {
+    open: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<TooltipRootProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (value: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<TooltipRootProps> & Readonly<{
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/ui/tooltip/TooltipContent.d.vue.ts

@@ -0,0 +1,24 @@
+import type { TooltipContentProps } from "reka-ui";
+import type { HTMLAttributes } from "vue";
+type __VLS_Props = TooltipContentProps & {
+    class?: HTMLAttributes["class"];
+};
+declare var __VLS_14: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_14) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: Event) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: Event) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};