@byyuurin/ui 0.0.11 → 0.1.0

package/dist/runtime/composables/useFormField.d.ts

@@ -0,0 +1,62 @@
+import type { UseEventBusReturn } from '@vueuse/core';
+import type { ComputedRef, Ref } from 'vue';
+import type { FormErrorWithId, FormEvent, FormFieldProps } from '../types';
+import type { GetObjectField, MaybeNull } from '../types/utils';
+export interface FormOptionsProvideValue {
+    disabled: boolean;
+    validateOnInputDelay: number;
+}
+export declare const InjectionKeyFormOptions: import("vue").InjectionKey<ComputedRef<FormOptionsProvideValue>>, injectFormOptions: () => ComputedRef<FormOptionsProvideValue> | undefined, provideFormOptions: (value: ComputedRef<FormOptionsProvideValue>) => void;
+export type FormBusProvideValue = UseEventBusReturn<FormEvent<any>, string>;
+export declare const InjectionKeyFormBus: import("vue").InjectionKey<FormBusProvideValue>, injectFormBus: () => FormBusProvideValue | undefined, provideFormBus: (value: FormBusProvideValue) => void;
+export type FormStateProvideValue = Record<string, any>;
+export declare const InjectionKeyFormState: import("vue").InjectionKey<ComputedRef<FormStateProvideValue>>, injectFormState: () => ComputedRef<FormStateProvideValue> | undefined, provideFormState: (value: ComputedRef<FormStateProvideValue>) => void;
+export interface FormFieldProvideValue<T> {
+    name?: string;
+    size?: GetObjectField<T, 'size'>;
+    error?: string | boolean;
+    eagerValidation?: boolean;
+    validateOnInputDelay?: number;
+    errorPattern?: RegExp;
+    hint?: string;
+    help?: string;
+    description?: string;
+    ariaId: string;
+}
+export declare const InjectionKeyFormField: import("vue").InjectionKey<ComputedRef<FormFieldProvideValue<FormFieldProps>>>, injectFormField: () => ComputedRef<FormFieldProvideValue<FormFieldProps>> | undefined, provideFormField: (value: ComputedRef<FormFieldProvideValue<FormFieldProps>>) => void;
+export declare const InjectionKeyFormInputId: import("vue").InjectionKey<Ref<string | undefined, string | undefined>>, injectFormInputId: () => Ref<string | undefined, string | undefined> | undefined, provideFormInputId: (value: Ref<string | undefined, string | undefined>) => void;
+export type FormInputsProvideValue = Record<string, {
+    id?: string;
+    pattern?: RegExp;
+}>;
+export declare const InjectionKeyFormInputs: import("vue").InjectionKey<Ref<FormInputsProvideValue, FormInputsProvideValue>>, injectFormInputs: () => Ref<FormInputsProvideValue, FormInputsProvideValue> | undefined, provideFormInputs: (value: Ref<FormInputsProvideValue, FormInputsProvideValue>) => void;
+export declare const InjectionKeyFormLoading: import("vue").InjectionKey<Readonly<Ref<boolean, boolean>>>, injectFormLoading: () => Readonly<Ref<boolean, boolean>> | undefined, provideFormLoading: (value: Readonly<Ref<boolean, boolean>>) => void;
+export declare const InjectionKeyFormErrors: import("vue").InjectionKey<MaybeNull<Ref<FormErrorWithId[], FormErrorWithId[]>>>, injectFormErrors: () => MaybeNull<Ref<FormErrorWithId[], FormErrorWithId[]>>, provideFormErrors: (value: MaybeNull<Ref<FormErrorWithId[], FormErrorWithId[]>>) => void;
+interface Props<T> {
+    id?: string;
+    name?: string;
+    size?: GetObjectField<T, 'size'>;
+    color?: GetObjectField<T, 'color'>;
+    highlight?: boolean;
+    disabled?: boolean;
+}
+export declare function useFormField<T>(props?: Props<T>, options?: {
+    bind?: boolean;
+    deferInputValidation?: boolean;
+}): {
+    id: ComputedRef<string | undefined>;
+    name: ComputedRef<string | undefined>;
+    size: ComputedRef<"xs" | "sm" | "md" | "lg" | "xl" | NonNullable<GetObjectField<T, "size">> | undefined>;
+    color: ComputedRef<"error" | GetObjectField<T, "color"> | undefined>;
+    highlight: ComputedRef<boolean | undefined>;
+    disabled: ComputedRef<boolean | undefined>;
+    emitFormBlur: () => void;
+    emitFormInput: import("@vueuse/core").UseDebounceFnReturn<() => void>;
+    emitFormChange: () => void;
+    emitFormFocus: () => void;
+    ariaAttrs: ComputedRef<{
+        'aria-describedby': string;
+        'aria-invalid': boolean;
+    } | undefined>;
+};
+export {};

package/dist/runtime/composables/useFormField.js

@@ -0,0 +1,99 @@
+import { useDebounceFn } from "@vueuse/core";
+import { computed } from "vue";
+import { defineInjection } from "../utils/index.js";
+export const {
+  InjectionKey: InjectionKeyFormOptions,
+  inject: injectFormOptions,
+  provide: provideFormOptions
+} = defineInjection("ui.form-options");
+export const {
+  InjectionKey: InjectionKeyFormBus,
+  inject: injectFormBus,
+  provide: provideFormBus
+} = defineInjection("ui.form-bus");
+export const {
+  InjectionKey: InjectionKeyFormState,
+  inject: injectFormState,
+  provide: provideFormState
+} = defineInjection("ui.form-state");
+export const {
+  InjectionKey: InjectionKeyFormField,
+  inject: injectFormField,
+  provide: provideFormField
+} = defineInjection("ui.form-field");
+export const {
+  InjectionKey: InjectionKeyFormInputId,
+  inject: injectFormInputId,
+  provide: provideFormInputId
+} = defineInjection("ui.form-input-id");
+export const {
+  InjectionKey: InjectionKeyFormInputs,
+  inject: injectFormInputs,
+  provide: provideFormInputs
+} = defineInjection("ui.form-inputs");
+export const {
+  InjectionKey: InjectionKeyFormLoading,
+  inject: injectFormLoading,
+  provide: provideFormLoading
+} = defineInjection("ui.form-loading");
+export const {
+  InjectionKey: InjectionKeyFormErrors,
+  inject: injectFormErrors,
+  provide: provideFormErrors
+} = defineInjection("ui.form-errors", null);
+export function useFormField(props, options) {
+  const formOptions = injectFormOptions();
+  const formBus = injectFormBus();
+  const formField = injectFormField();
+  const formInputs = injectFormInputs();
+  const inputId = injectFormInputId();
+  if (formField && inputId) {
+    if (options?.bind === false) {
+      inputId.value = void 0;
+    } else if (props?.id) {
+      inputId.value = props?.id;
+    }
+    if (formInputs && formField.value.name && inputId.value)
+      formInputs.value[formField.value.name] = { id: inputId.value, pattern: formField.value.errorPattern };
+  }
+  function emitFormEvent(type, name, eager) {
+    if (formBus && formField && name)
+      formBus.emit({ type, name, eager });
+  }
+  function emitFormBlur() {
+    emitFormEvent("blur", formField?.value.name);
+  }
+  function emitFormFocus() {
+    emitFormEvent("focus", formField?.value.name);
+  }
+  function emitFormChange() {
+    emitFormEvent("change", formField?.value.name);
+  }
+  const emitFormInput = useDebounceFn(
+    () => {
+      emitFormEvent("input", formField?.value.name, !options?.deferInputValidation || formField?.value.eagerValidation);
+    },
+    formField?.value.validateOnInputDelay ?? formOptions?.value.validateOnInputDelay ?? 0
+  );
+  return {
+    id: computed(() => props?.id ?? inputId?.value),
+    name: computed(() => props?.name ?? formField?.value.name),
+    size: computed(() => props?.size ?? formField?.value.size),
+    color: computed(() => formField?.value.error ? "error" : props?.color),
+    highlight: computed(() => formField?.value.error ? true : props?.highlight),
+    disabled: computed(() => formOptions?.value.disabled || props?.disabled),
+    emitFormBlur,
+    emitFormInput,
+    emitFormChange,
+    emitFormFocus,
+    ariaAttrs: computed(() => {
+      if (!formField?.value)
+        return;
+      const descriptiveAttrs = ["error", "hint", "help", "description"].filter((type) => formField?.value?.[type]).map((type) => `${formField?.value.ariaId}-${type}`) || [];
+      return {
+        "aria-describedby": descriptiveAttrs.join(" "),
+        "aria-invalid": !!formField?.value.error
+      };
+    })
+  };
+}

package/dist/runtime/composables/useKbd.d.ts

@@ -28,8 +28,9 @@ export declare const kbdKeysMap: {
 };
 export type KbdKey = keyof typeof kbdKeysMap;
 export type KbdKeySpecific = keyof KbdKeysSpecificMap;
-export declare const useKbd: () => {
-    macOS: import("vue").ComputedRef<any>;
+declare function _useKbd(): {
+    macOS: import("vue").ComputedRef<false | "" | RegExpMatchArray | null>;
     getKbdKey: (value?: KbdKey | (string & {})) => string | undefined;
 };
+export declare const useKbd: typeof _useKbd;
 export {};

package/dist/runtime/composables/useKbd.js

@@ -23,7 +23,7 @@ export const kbdKeysMap = {
   home: "\u2196",
   end: "\u2198"
 };
-export const useKbd = createSharedComposable(() => {
+function _useKbd() {
   const macOS = computed(() => import.meta.client && navigator && navigator.userAgent && navigator.userAgent.match(/Macintosh;/));
   const kbdKeysSpecificMap = reactive({
     meta: " ",
@@ -46,4 +46,5 @@ export const useKbd = createSharedComposable(() => {
     macOS,
     getKbdKey
   };
-});
+}
+export const useKbd = /* @__PURE__ */ createSharedComposable(_useKbd);

package/dist/runtime/composables/useLocale.d.ts

@@ -1,8 +1,71 @@
-import type { Translator } from '../utils/translator.js';
-export declare const useLocale: () => {
-    locale: import("vue").ComputedRef<import("../utils/index.js").Locale<import("../types/index.js").Messages>>;
+import type { Translator } from '@byyuurin/ui-kit';
+import type { MaybeRefOrGetter } from 'vue';
+import type { Messages } from '../types';
+export declare const InjectionKeyLocaleContext: import("vue").InjectionKey<MaybeRefOrGetter<Required<import("@byyuurin/ui-kit").Locale<Messages>> | undefined>>, injectLocaleContext: () => MaybeRefOrGetter<Required<import("@byyuurin/ui-kit").Locale<Messages>> | undefined>, provideLocaleContext: (value: MaybeRefOrGetter<Required<import("@byyuurin/ui-kit").Locale<Messages>> | undefined>) => void;
+declare function _useLocale(): {
+    locale: import("vue").ComputedRef<Required<import("@byyuurin/ui-kit").Locale<{
+        alert: {
+            close: string;
+        };
+        calendar: {
+            prevYear: string;
+            nextYear: string;
+            prevMonth: string;
+            nextMonth: string;
+        };
+        carousel: {
+            dots: string;
+            prev: string;
+            next: string;
+            goto: string;
+        };
+        inputNumber: {
+            increment: string;
+            decrement: string;
+        };
+        modal: {
+            close: string;
+        };
+        table: {
+            noData: string;
+        };
+        toast: {
+            close: string;
+        };
+    }>>>;
     lang: import("vue").ComputedRef<string>;
     code: import("vue").ComputedRef<string>;
-    dir: import("vue").ComputedRef<import("../utils/index.js").Direction>;
-    t: Translator<import("../types/index.js").Messages>;
+    dir: import("vue").ComputedRef<import("@byyuurin/ui-kit").LocaleDirection>;
+    t: Translator<{
+        alert: {
+            close: string;
+        };
+        calendar: {
+            prevYear: string;
+            nextYear: string;
+            prevMonth: string;
+            nextMonth: string;
+        };
+        carousel: {
+            dots: string;
+            prev: string;
+            next: string;
+            goto: string;
+        };
+        inputNumber: {
+            increment: string;
+            decrement: string;
+        };
+        modal: {
+            close: string;
+        };
+        table: {
+            noData: string;
+        };
+        toast: {
+            close: string;
+        };
+    }>;
 };
+export declare const useLocale: typeof _useLocale;
+export {};

package/dist/runtime/composables/useLocale.js

@@ -1,9 +1,14 @@
 import { createSharedComposable } from "@vueuse/core";
 import { computed, toValue } from "vue";
-import { injectLocaleContext } from "../app/injections.js";
 import localeDefault from "../locale/en.js";
-import { createTranslator } from "../utils/index.js";
-export const useLocale = createSharedComposable(() => {
+import { defineInjection } from "../utils/index.js";
+import { createTranslator } from "../utils/locale.js";
+export const {
+  InjectionKey: InjectionKeyLocaleContext,
+  inject: injectLocaleContext,
+  provide: provideLocaleContext
+} = defineInjection("ui.locale-context");
+function _useLocale() {
   const _locale = injectLocaleContext();
   const locale = computed(() => toValue(_locale) ?? localeDefault);
   const lang = computed(() => locale.value.name);
@@ -12,11 +17,6 @@ export const useLocale = createSharedComposable(() => {
   const t = (path, options) => {
     return createTranslator(toValue(locale))(path, options);
   };
-  return {
-    locale,
-    lang,
-    code,
-    dir,
-    t
-  };
-});
+  return { locale, lang, code, dir, t };
+}
+export const useLocale = import.meta.client ? createSharedComposable(_useLocale) : _useLocale;

package/dist/runtime/composables/useOverlay.d.ts

@@ -1,29 +1,65 @@
 import type { Component } from 'vue';
-import type { ComponentProps } from 'vue-component-type-helpers';
+import type { ComponentEmit, ComponentProps } from 'vue-component-type-helpers';
+/**
+ * This is a workaround for a design limitation in TypeScript.
+ *
+ * Conditional types only match the last function overload, not a union of all possible
+ * parameter types. This workaround forces TypeScript to properly extract the 'close'
+ * event argument type from component emits with multiple event signatures.
+ *
+ * @see https://github.com/microsoft/TypeScript/issues/32164
+ */
+type CloseEventArgType<T> = T extends {
+    (event: 'close', arg_0: infer Arg, ...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+    (...args: any[]): void;
+} ? Arg : never;
 export interface OverlayOptions<ComponentProps = Record<string, any>> {
     defaultOpen?: boolean;
     props?: ComponentProps;
     unmountOnHide?: boolean;
 }
-interface _ComponentState<T extends Component> {
+interface OverlayOptionsPrivate<T extends Component> {
     component?: T;
-    id: string | number;
+    id: symbol;
     isMounted: boolean;
-    modelValue: boolean;
-    resolve?: (value: unknown) => void;
+    isOpen: boolean;
+    originalProps?: ComponentProps<T>;
+    resolvePromise?: (value: unknown) => void;
 }
-export type OverlayComponentState = OverlayOptions<Component> & _ComponentState<Component>;
-export interface OverlayComponentInstance<T> {
-    open: (props?: ComponentProps<T>) => Promise<any>;
+export type Overlay = OverlayOptions<Component> & OverlayOptionsPrivate<Component>;
+type OpenedOverlay<T extends Component> = Omit<OverlayInstance<T>, 'open' | 'close' | 'patch' | 'modelValue' | 'resolvePromise'> & {
+    result: Promise<CloseEventArgType<ComponentEmit<T>>>;
+} & Promise<CloseEventArgType<ComponentEmit<T>>>;
+export interface OverlayInstance<T extends Component> {
+    id: symbol;
+    open: (props?: ComponentProps<T>) => OpenedOverlay<T>;
     close: (value?: any) => void;
     patch: (props: Partial<ComponentProps<T>>) => void;
 }
-export declare const useOverlay: () => {
-    overlays: import("vue").ShallowReactive<OverlayComponentState[]>;
-    open: <T extends Component>(id: OverlayComponentState["id"], props?: ComponentProps<T>) => Promise<any>;
-    close: (id: OverlayComponentState["id"], value?: any) => void;
-    create: <T extends Component>(component: T, options?: OverlayOptions<ComponentProps<T>>) => OverlayComponentInstance<T>;
-    patch: <T extends Component>(id: OverlayComponentState["id"], props: Partial<ComponentProps<T>>) => void;
-    unmount: (id: OverlayComponentState["id"]) => void;
+declare function _useOverlay(): {
+    overlays: import("vue").ShallowReactive<Overlay[]>;
+    open: <T extends Component>(id: Overlay["id"], props?: ComponentProps<T>) => OpenedOverlay<T>;
+    close: (id: symbol, value?: any) => void;
+    closeAll: () => void;
+    create: <T extends Component>(component: T, options?: OverlayOptions<ComponentProps<T>>) => OverlayInstance<T>;
+    patch: <T extends Component>(id: symbol, props: Partial<ComponentProps<T>>) => void;
+    unmount: (id: symbol) => void;
+    isOpen: (id: symbol) => boolean;
 };
+export declare const useOverlay: typeof _useOverlay;
 export {};

package/dist/runtime/composables/useOverlay.js

@@ -1,43 +1,52 @@
 import { createSharedComposable } from "@vueuse/core";
 import { markRaw, reactive, shallowReactive } from "vue";
-export const useOverlay = createSharedComposable(() => {
+function _useOverlay() {
   const overlays = shallowReactive([]);
-  const generateId = () => `overlay-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
-  function create(component, options = {}) {
-    const { props = {}, defaultOpen = false, unmountOnHide = true } = options;
-    const state = reactive({
-      id: generateId(),
-      modelValue: defaultOpen,
-      component: markRaw(component),
+  function create(component, options) {
+    const { props = {}, defaultOpen = false, unmountOnHide = true } = options || {};
+    const optionsPrivate = reactive({
+      id: Symbol(import.meta.dev ? "useOverlay" : ""),
+      isOpen: defaultOpen,
       isMounted: defaultOpen,
+      component: markRaw(component),
+      originalProps: props,
       unmountOnHide,
-      props
+      props: { ...props }
     });
-    overlays.push(state);
+    overlays.push(optionsPrivate);
     return {
-      open: (props2) => open(state.id, props2),
-      close: (value) => close(state.id, value),
-      patch: (props2) => patch(state.id, props2)
+      ...optionsPrivate,
+      open: (props2) => open(optionsPrivate.id, props2),
+      close: (value) => close(optionsPrivate.id, value),
+      patch: (props2) => patch(optionsPrivate.id, props2)
     };
   }
   function open(id, props) {
     const overlay = getOverlay(id);
-    if (props)
-      patch(id, props);
-    overlay.modelValue = true;
+    overlay.props = props ? { ...overlay.originalProps, ...props } : { ...overlay.originalProps };
+    overlay.isOpen = true;
     overlay.isMounted = true;
-    return new Promise((resolve) => {
-      overlay.resolve = resolve;
+    const result = new Promise((resolve) => {
+      overlay.resolvePromise = resolve;
+    });
+    return Object.assign(result, {
+      id,
+      isMounted: overlay.isMounted,
+      isOpen: overlay.isOpen,
+      result
     });
   }
   function close(id, value) {
     const overlay = getOverlay(id);
-    overlay.modelValue = false;
-    if (overlay.resolve) {
-      overlay.resolve(value);
-      overlay.resolve = void 0;
+    overlay.isOpen = false;
+    if (overlay.resolvePromise) {
+      overlay.resolvePromise(value);
+      overlay.resolvePromise = void 0;
     }
   }
+  function closeAll() {
+    overlays.forEach((overlay) => close(overlay.id));
+  }
   function unmount(id) {
     const overlay = getOverlay(id);
     overlay.isMounted = false;
@@ -48,22 +57,27 @@ export const useOverlay = createSharedComposable(() => {
   }
   function patch(id, props) {
     const overlay = getOverlay(id);
-    Object.entries(props).forEach(([key, value]) => {
-      overlay.props[key] = value;
-    });
+    overlay.props = { ...overlay.props, ...props };
   }
   function getOverlay(id) {
-    const item = overlays.find((item2) => item2.id === id);
-    if (!item)
+    const overlay = overlays.find((item) => item.id === id);
+    if (!overlay)
       throw new Error("Overlay not found");
-    return item;
+    return overlay;
+  }
+  function isOpen(id) {
+    const overlay = getOverlay(id);
+    return overlay.isOpen;
   }
   return {
     overlays,
     open,
     close,
+    closeAll,
     create,
     patch,
-    unmount
+    unmount,
+    isOpen
   };
-});
+}
+export const useOverlay = /* @__PURE__ */ createSharedComposable(_useOverlay);

package/dist/runtime/composables/usePortal.d.ts

@@ -0,0 +1,6 @@
+import { type Ref } from 'vue';
+export declare const InjectionKeyPortalTarget: import("vue").InjectionKey<Ref<string | boolean | HTMLElement | undefined, string | boolean | HTMLElement | undefined>>, injectPortalTarget: () => Ref<string | boolean | HTMLElement | undefined, string | boolean | HTMLElement | undefined> | undefined, providePortalTarget: (value: Ref<string | boolean | HTMLElement | undefined, string | boolean | HTMLElement | undefined>) => void;
+export declare function usePortal(portal: Ref<boolean | string | HTMLElement | undefined>): import("vue").ComputedRef<{
+    to: string | HTMLElement | undefined;
+    disabled: boolean;
+}>;

package/dist/runtime/composables/usePortal.js

@@ -0,0 +1,17 @@
+import { computed } from "vue";
+import { defineInjection } from "../utils/index.js";
+export const {
+  InjectionKey: InjectionKeyPortalTarget,
+  inject: injectPortalTarget,
+  provide: providePortalTarget
+} = defineInjection("ui.portal-target");
+export function usePortal(portal) {
+  const globalPortal = injectPortalTarget();
+  const value = computed(() => portal.value === true ? globalPortal?.value : portal.value);
+  const disabled = computed(() => typeof value.value === "boolean" ? !value.value : false);
+  const to = computed(() => typeof value.value === "boolean" ? "body" : value.value);
+  return computed(() => ({
+    to: to.value,
+    disabled: disabled.value
+  }));
+}

package/dist/runtime/composables/useToast.d.ts

@@ -1,8 +1,15 @@
-import type { ToastState } from '../types/index.js';
-export declare const useToast: () => {
-    toasts: any;
-    add: (toast: Partial<ToastState>) => ToastState;
-    update: (id: string | number, toast: Partial<Omit<ToastState, "id">>) => void;
+import type { Ref } from 'vue';
+import type { ToastEmits, ToastProps } from '../types';
+import type { EmitsToProps } from '../types/utils';
+export declare const InjectionKeyToastMax: import("vue").InjectionKey<Ref<number, number>>, injectToastMax: () => Ref<number, number> | undefined, provideToastMax: (value: Ref<number, number>) => void;
+export interface Toast extends Omit<ToastProps, 'defaultOpen'>, EmitsToProps<ToastEmits> {
+    id: string | number;
+    onClick?: (toast: Toast) => void;
+}
+export declare function useToast(): {
+    toasts: Ref<Toast[], Toast[]>;
+    add: (toast: Partial<Toast>) => Toast;
+    update: (id: string | number, toast: Partial<Omit<Toast, "id">>) => void;
     remove: (id: string | number) => void;
     clear: () => void;
 };

package/dist/runtime/composables/useToast.js

@@ -1,11 +1,16 @@
-import { createSharedComposable } from "@vueuse/core";
-import { nextTick, ref } from "vue";
+import { nextTick, shallowRef } from "vue";
 import { useState } from "#imports";
-export const useToast = createSharedComposable(() => {
+import { defineInjection } from "../utils/index.js";
+export const {
+  InjectionKey: InjectionKeyToastMax,
+  inject: injectToastMax,
+  provide: provideToastMax
+} = defineInjection("ui.toast-max");
+export function useToast() {
   const toasts = useState("toasts", () => []);
-  const running = ref(false);
-  const maxToasts = 5;
+  const max = injectToastMax();
   const queue = [];
+  const running = shallowRef(false);
   const generateId = () => `toast-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
   async function processQueue() {
     if (running.value || queue.length === 0)
@@ -14,7 +19,7 @@ export const useToast = createSharedComposable(() => {
     while (queue.length > 0) {
       const toast = queue.shift();
       await nextTick();
-      toasts.value = [...toasts.value, toast].slice(-maxToasts);
+      toasts.value = [...toasts.value, toast].slice(-(max?.value ?? 5));
     }
     running.value = false;
   }
@@ -59,4 +64,4 @@ export const useToast = createSharedComposable(() => {
     remove,
     clear
   };
-});
+}

package/dist/runtime/locale/en.d.ts

@@ -1,2 +1,31 @@
-declare const _default: import("../utils/index.js").Locale<import("../types/index.js").Messages>;
+declare const _default: Required<import("@byyuurin/ui-kit").Locale<{
+    alert: {
+        close: string;
+    };
+    calendar: {
+        prevYear: string;
+        nextYear: string;
+        prevMonth: string;
+        nextMonth: string;
+    };
+    carousel: {
+        dots: string;
+        prev: string;
+        next: string;
+        goto: string;
+    };
+    inputNumber: {
+        increment: string;
+        decrement: string;
+    };
+    modal: {
+        close: string;
+    };
+    table: {
+        noData: string;
+    };
+    toast: {
+        close: string;
+    };
+}>>;
 export default _default;

package/dist/runtime/locale/en.js

@@ -1,4 +1,4 @@
-import { defineLocale } from "../utils/index.js";
+import { defineLocale } from "../utils/locale.js";
 export default defineLocale({
   name: "English",
   code: "en",
@@ -13,6 +13,7 @@ export default defineLocale({
       nextMonth: "Next month"
     },
     carousel: {
+      dots: "Choose slide to display",
       prev: "Prev",
       next: "Next",
       goto: "Go to slide {page}"

package/dist/runtime/locale/index.d.ts

@@ -1,2 +1,2 @@
-export { default as en } from './en.js';
-export { default as zhTW } from './zh-tw.js';
+export { default as en } from './en';
+export { default as zh_tw } from './zh_tw';

package/dist/runtime/locale/index.js

@@ -1,2 +1,2 @@
 export { default as en } from "./en.js";
-export { default as zhTW } from "./zh-tw.js";
+export { default as zh_tw } from "./zh_tw.js";