vueless 0.0.478-beta.5 → 0.0.478-beta.7

package/adatper.locale/vue-i18n.ts

@@ -0,0 +1,14 @@
+import type { I18n } from "vue-i18n";
+
+export default function createVueI18nAdapter(i18n: I18n) {
+  return {
+    name: "vue-i18n",
+    locale: i18n.global.locale,
+    fallback: i18n.global.fallbackLocale,
+    messages: i18n.global.messages,
+    // @ts-expect-error Type instantiation is excessively deep and possibly infinite
+    t: (key: string, ...params: unknown[]) => i18n.global.t(key, params),
+    tm: i18n.global.tm,
+    n: i18n.global.n,
+  };
+}

package/adatper.locale/{vueless.js → vueless.ts}

@@ -1,11 +1,35 @@
 import { shallowRef, ref } from "vue";
 import { merge } from "lodash-es";
 
-import en from "./locales/en.js";
+import en from "./locales/en.ts";
+
+import type { Ref } from "vue";
+import type { UnknownObject } from "../types.ts";
+
+export interface LocaleMessages {
+  [key: string]: LocaleMessages | string;
+}
+
+export interface LocaleOptions {
+  messages?: LocaleMessages;
+  locale?: string;
+  fallback?: string;
+  adapter?: LocaleInstance;
+}
+
+export interface LocaleInstance {
+  name: string;
+  messages: Ref<LocaleMessages>;
+  locale: Ref<string>;
+  fallback: Ref<string>;
+  t: (key: string, ...params: unknown[]) => string;
+  n: (value: number) => string;
+  tm: (key: string, ...params: unknown[]) => string;
+}
 
 const FALLBACK_LOCALE_CODE = "en";
 
-export default function createVuelessAdapter(options) {
+export default function createVuelessAdapter(options?: LocaleOptions): LocaleInstance {
   const current = shallowRef(options?.locale ?? FALLBACK_LOCALE_CODE);
   const fallback = shallowRef(options?.fallback ?? FALLBACK_LOCALE_CODE);
 
@@ -22,12 +46,16 @@ export default function createVuelessAdapter(options) {
   };
 }
 
-function createTranslateFunction(current, fallback, messages) {
-  return (key, ...params) => {
+function createTranslateFunction(
+  current: Ref<string>,
+  fallback: Ref<string>,
+  messages: Ref<LocaleMessages>,
+) {
+  return (key: string, ...params: unknown[]) => {
     const currentLocale = current.value && messages.value[current.value];
     const fallbackLocale = fallback.value && messages.value[fallback.value];
 
-    let str = getObjectValueByPath(currentLocale, key, null);
+    let str = getObjectValueByPath<LocaleMessages | string, unknown>(currentLocale, key, null);
 
     if (!str) {
       // eslint-disable-next-line no-console
@@ -49,16 +77,20 @@ function createTranslateFunction(current, fallback, messages) {
       str = key;
     }
 
-    return replace(str, params);
+    return replace(String(str), params);
   };
 }
 
-function createTranslateMessageFunction(current, fallback, messages) {
-  return (key) => {
+function createTranslateMessageFunction(
+  current: Ref<string>,
+  fallback: Ref<string>,
+  messages: Ref<LocaleMessages>,
+) {
+  return (key: string) => {
     const currentLocale = current.value && messages.value[current.value];
     const fallbackLocale = fallback.value && messages.value[fallback.value];
 
-    let str = getObjectValueByPath(currentLocale, key, null);
+    let str = getObjectValueByPath<LocaleMessages | string, unknown>(currentLocale, key, null);
 
     if (str === undefined) {
       // eslint-disable-next-line no-console
@@ -68,51 +100,67 @@ function createTranslateMessageFunction(current, fallback, messages) {
       str = getObjectValueByPath(fallbackLocale, key, null);
     }
 
-    return str;
+    return String(str);
   };
 }
 
-const replace = (str, params) => {
+const replace = (str: string, params: unknown[]) => {
   return str.replace(/\{(\d+)\}/g, (match, index) => {
     return String(params[+index]);
   });
 };
 
-function createNumberFunction(current, fallback) {
-  return (value, options) => {
+function createNumberFunction(current: Ref<string>, fallback: Ref<string>) {
+  return (value: number, options?: Intl.NumberFormatOptions) => {
     const numberFormat = new Intl.NumberFormat([current.value, fallback.value], options);
 
     return numberFormat.format(value);
   };
 }
 
-export function getObjectValueByPath(obj, path, fallback) {
+export function getObjectValueByPath<T, K = unknown>(
+  obj: T,
+  path?: string,
+  fallback?: K,
+): K | undefined {
   if (obj == null || !path || typeof path !== "string") return fallback;
-  if (obj[path] !== undefined) return obj[path];
+
+  const unknownObject = obj as UnknownObject;
+
+  if (unknownObject[path] !== undefined) {
+    return unknownObject[path] as K;
+  }
+
   path = path.replace(/\[(\w+)\]/g, ".$1"); // convert indexes to properties
   path = path.replace(/^\./, ""); // strip a leading dot
 
   return getNestedValue(obj, path.split("."), fallback);
 }
 
-export function getNestedValue(obj, path, fallback) {
+export function getNestedValue<T, K = unknown>(
+  obj: T | null | undefined,
+  path: (string | number)[],
+  fallback?: K,
+): K | undefined {
   const last = path.length - 1;
 
   if (last < 0) {
-    return obj === undefined ? fallback : obj;
+    return obj === undefined ? fallback : (obj as unknown as K);
   }
 
+  const unknownObject = obj as Record<string | number, unknown>;
+
   for (let i = 0; i < last; i++) {
     if (obj == null) {
       return fallback;
     }
 
-    obj = obj[path[i]];
+    obj = unknownObject[path[i]] as T;
   }
 
   if (obj == null) {
     return fallback;
   }
 
-  return obj[path[last]] === undefined ? fallback : obj[path[last]];
+  return (unknownObject[path[last]] === undefined ? fallback : unknownObject[path[last]]) as K;
 }

package/composablesTs/useAutoPosition.ts

@@ -1,14 +1,9 @@
 import { computed, toValue, ref } from "vue";
 import { isSSR } from "../utilsTs/utilHelper.ts";
 
-import type { Ref, ComputedRef } from "vue";
+import type { ComputedRef, MaybeRef, Reactive } from "vue";
 
-interface PositionXY {
-  x: Position;
-  y: Position;
-}
-
-export enum Position {
+export enum Direction {
   Left = "left",
   Right = "right",
   Top = "top",
@@ -16,62 +11,56 @@ export enum Position {
   Auto = "auto",
 }
 
-// TODO: Remove after full TS migration, use enum instead.
-export const POSITION = {
-  left: "left",
-  right: "right",
-  top: "top",
-  bottom: "bottom",
-  auto: "auto",
-};
+export type Align = `${Direction}`;
+export type Position = { x: Align; y: Align };
 
 export function useAutoPosition(
-  anchorElement: Ref<HTMLElement | null>,
-  targetElement: Ref<HTMLElement | null>,
-  position: PositionXY | ComputedRef<PositionXY>,
-  preferredPosition: PositionXY | ComputedRef<PositionXY>,
+  anchorElement: MaybeRef<HTMLElement | null>,
+  targetElement: MaybeRef<HTMLElement | null>,
+  position: Reactive<Position> | ComputedRef<Position>,
+  preferredPosition: Reactive<Position> | ComputedRef<Position>,
 ) {
   const localAnchorElement = computed(() => toValue(anchorElement));
   const localTargetElement = computed(() => toValue(targetElement));
   const localPosition = computed(() => toValue(position));
   const localPreferredPosition = computed(() => toValue(preferredPosition));
 
-  const preferredOpenDirectionY = ref(localPreferredPosition.value?.y || Position.Bottom);
-  const preferredOpenDirectionX = ref(localPreferredPosition.value?.x || Position.Left);
+  const preferredOpenDirectionY = ref(localPreferredPosition.value.y || Direction.Bottom);
+  const preferredOpenDirectionX = ref(localPreferredPosition.value.x || Direction.Left);
 
   const isTop = computed(() => {
-    if (localPosition.value.y !== Position.Auto) {
-      return localPosition.value.y === Position.Top;
+    if (localPosition.value.y !== Direction.Auto) {
+      return localPosition.value.y === Direction.Top;
     }
 
-    return preferredOpenDirectionY.value === Position.Top;
+    return preferredOpenDirectionY.value === Direction.Top;
   });
 
   const isLeft = computed(() => {
-    if (localPosition.value.x !== Position.Auto) {
-      return localPosition.value.x === Position.Left;
+    if (localPosition.value.x !== Direction.Auto) {
+      return localPosition.value.x === Direction.Left;
     }
 
-    return preferredOpenDirectionX.value === Position.Left;
+    return preferredOpenDirectionX.value === Direction.Left;
   });
 
   const isBottom = computed(() => {
-    if (localPosition.value.y !== Position.Auto) {
-      return localPosition.value.y === Position.Bottom;
+    if (localPosition.value.y !== Direction.Auto) {
+      return localPosition.value.y === Direction.Bottom;
     }
 
-    return preferredOpenDirectionY.value === Position.Bottom;
+    return preferredOpenDirectionY.value === Direction.Bottom;
   });
 
   const isRight = computed(() => {
-    if (localPosition.value.x !== Position.Auto) {
-      return localPosition.value.x === Position.Right;
+    if (localPosition.value.x !== Direction.Auto) {
+      return localPosition.value.x === Direction.Right;
     }
 
-    return preferredOpenDirectionX.value === Position.Right;
+    return preferredOpenDirectionX.value === Direction.Right;
   });
 
-  function adjustPositionY(): void {
+  function adjustPositionY() {
     if (isSSR || !localAnchorElement.value || !localTargetElement.value) return;
 
     const spaceAbove = localAnchorElement.value.getBoundingClientRect().top;
@@ -81,18 +70,18 @@ export function useAutoPosition(
     const hasEnoughSpaceAbove =
       spaceAbove > localTargetElement.value.getBoundingClientRect().height;
 
-    if (localPreferredPosition.value.y === Position.Bottom) {
+    if (localPreferredPosition.value.y === Direction.Bottom) {
       preferredOpenDirectionY.value =
-        hasEnoughSpaceBelow || spaceBelow > spaceAbove ? Position.Bottom : Position.Top;
+        hasEnoughSpaceBelow || spaceBelow > spaceAbove ? Direction.Bottom : Direction.Top;
     }
 
-    if (localPreferredPosition.value.y === Position.Top) {
+    if (localPreferredPosition.value.y === Direction.Top) {
       preferredOpenDirectionY.value =
-        hasEnoughSpaceAbove || spaceAbove > spaceBelow ? Position.Top : Position.Bottom;
+        hasEnoughSpaceAbove || spaceAbove > spaceBelow ? Direction.Top : Direction.Bottom;
     }
   }
 
-  function adjustPositionX(): void {
+  function adjustPositionX() {
     if (isSSR || !localAnchorElement.value || !localTargetElement.value) return;
 
     const spaceRight = localAnchorElement.value.getBoundingClientRect().right;
@@ -100,14 +89,14 @@ export function useAutoPosition(
     const hasEnoughSpaceLeft = spaceLeft > localTargetElement.value.getBoundingClientRect().width;
     const hasEnoughSpaceRight = spaceRight > localTargetElement.value.getBoundingClientRect().width;
 
-    if (localPreferredPosition.value.x === Position.Right) {
+    if (localPreferredPosition.value.x === Direction.Right) {
       preferredOpenDirectionX.value =
-        hasEnoughSpaceRight || spaceRight > spaceLeft ? Position.Right : Position.Left;
+        hasEnoughSpaceRight || spaceRight > spaceLeft ? Direction.Right : Direction.Left;
     }
 
-    if (localPreferredPosition.value.x === Position.Left) {
+    if (localPreferredPosition.value.x === Direction.Left) {
       preferredOpenDirectionX.value =
-        hasEnoughSpaceLeft || spaceLeft > spaceRight ? Position.Left : Position.Right;
+        hasEnoughSpaceLeft || spaceLeft > spaceRight ? Direction.Left : Direction.Right;
     }
   }
 

package/composablesTs/useBreakpoint.ts

@@ -3,32 +3,34 @@ import { isSSR } from "../utilsTs/utilHelper.ts";
 
 import type { Ref } from "vue";
 
-const BREAKPOINT_NAME = {
-  xs: "xs",
-  sm: "sm",
-  md: "md",
-  lg: "lg",
-  xl: "xl",
-  "2xl": "2xl",
-};
-
-const BREAKPOINT = {
-  xs: 0,
-  sm: 640,
-  md: 768,
-  lg: 1024,
-  xl: 1280,
-  "2xl": 1536,
-};
+enum BreakpointName {
+  Xs = "xs",
+  Sm = "sm",
+  Md = "md",
+  Lg = "lg",
+  Xl = "xl",
+  "2xl" = "2xl",
+}
+
+enum BreakpointWidth {
+  Xs = 0,
+  Sm = 640,
+  Md = 768,
+  Lg = 1024,
+  Xl = 1280,
+  "2xl" = 1536,
+}
+
+type Breakpoint = `${BreakpointName}`;
 
 const mobileDevices = ["xs", "sm"];
 const portableDevices = ["xs", "sm", "md"];
 
 export default function useBreakpoint() {
-  let timeout: number;
+  let timeout: number | undefined;
 
-  const windowWidth: Ref<number | undefined> = ref(undefined);
-  const currentBreakpoint = ref(BREAKPOINT_NAME.xs);
+  const windowWidth = ref(0);
+  const currentBreakpoint: Ref<Breakpoint> = ref(BreakpointName.Xs);
 
   const isMobileBreakpoint = computed(() => {
     return mobileDevices.includes(currentBreakpoint.value);
@@ -39,15 +41,16 @@ export default function useBreakpoint() {
   });
 
   const isLaptopBreakpoint = computed(() => {
-    return currentBreakpoint.value === BREAKPOINT_NAME.lg;
+    return currentBreakpoint.value === BreakpointName.Lg;
   });
 
   const isPortableBreakpoint = computed(() => {
     return portableDevices.includes(currentBreakpoint.value);
   });
 
+  // TODO: Why do we need this? Maybe we should rename it.
   const elementSize = computed(() => {
-    return isMobileBreakpoint.value ? BREAKPOINT_NAME.md : BREAKPOINT_NAME.lg;
+    return isMobileBreakpoint.value ? BreakpointName.Md : BreakpointName.Lg;
   });
 
   onMounted(() => {
@@ -78,21 +81,21 @@ export default function useBreakpoint() {
     });
   }
 
-  function setBreakpoint(newWindowWidth: number | undefined) {
+  function setBreakpoint(newWindowWidth: number) {
     if (newWindowWidth === undefined) return;
 
     currentBreakpoint.value = "xs";
 
-    if (newWindowWidth >= BREAKPOINT.sm && newWindowWidth < BREAKPOINT.md) {
-      currentBreakpoint.value = "sm";
-    } else if (newWindowWidth >= BREAKPOINT.md && newWindowWidth < BREAKPOINT.lg) {
-      currentBreakpoint.value = "md";
-    } else if (newWindowWidth >= BREAKPOINT.lg && newWindowWidth < BREAKPOINT.xl) {
-      currentBreakpoint.value = "lg";
-    } else if (newWindowWidth >= BREAKPOINT.xl && newWindowWidth < BREAKPOINT["2xl"]) {
-      currentBreakpoint.value = "xl";
-    } else if (newWindowWidth >= BREAKPOINT["2xl"]) {
-      currentBreakpoint.value = "2xl";
+    if (newWindowWidth >= BreakpointWidth.Sm && newWindowWidth < BreakpointWidth.Sm) {
+      currentBreakpoint.value = BreakpointName.Sm;
+    } else if (newWindowWidth >= BreakpointWidth.Md && newWindowWidth < BreakpointWidth.Lg) {
+      currentBreakpoint.value = BreakpointName.Md;
+    } else if (newWindowWidth >= BreakpointWidth.Lg && newWindowWidth < BreakpointWidth.Xl) {
+      currentBreakpoint.value = BreakpointName.Lg;
+    } else if (newWindowWidth >= BreakpointWidth.Xl && newWindowWidth < BreakpointWidth["2xl"]) {
+      currentBreakpoint.value = BreakpointName.Xl;
+    } else if (newWindowWidth >= BreakpointWidth["2xl"]) {
+      currentBreakpoint.value = BreakpointName["2xl"];
     }
   }
 

package/composablesTs/useLocale.ts

@@ -1,17 +1,14 @@
 import { inject } from "vue";
-import createVuelessAdapter from "../adatper.locale/vueless.js";
+import createVuelessAdapter from "../adatper.locale/vueless.ts";
 
-export const LocaleSymbol = Symbol.for("vueless:locale");
+import type { LocaleInstance, LocaleOptions } from "../adatper.locale/vueless.ts";
+import type { InjectionKey } from "vue";
 
-function isLocaleInstance(obj): boolean {
-  return obj.name !== null;
-}
+export const LocaleSymbol: InjectionKey<LocaleInstance> = Symbol.for("vueless:locale");
 
-export function createLocale(options) {
+export function createLocale(options: LocaleOptions) {
   const i18n =
-    options?.adapter && isLocaleInstance(options?.adapter)
-      ? options?.adapter
-      : createVuelessAdapter(options);
+    options?.adapter && options?.adapter?.name ? options?.adapter : createVuelessAdapter(options);
 
   return { ...i18n };
 }

package/composablesTs/useMutationObserver.ts

@@ -1,41 +1,44 @@
-import { onBeforeUnmount, onMounted, toValue, watch } from "vue";
+import { computed, onBeforeUnmount, onMounted, toValue, watch } from "vue";
 import { isSSR } from "../utilsTs/utilHelper.ts";
 
-import type { Ref } from "vue";
+import type { TemplateRefElement } from "../types.ts";
 
 export function useMutationObserver(
-  target: Ref<HTMLElement | null>,
-  callBack: () => void,
+  target: TemplateRefElement,
+  callback: MutationCallback,
   config = { childList: true, attributes: true, characterData: true },
 ) {
   if (isSSR) return;
 
-  const observer = new MutationObserver(callBack);
+  const observer = new MutationObserver(callback);
+  const targetValue = computed(() => toValue(target));
 
   onMounted(() => {
-    if (!toValue(target)) return;
+    if (!targetValue.value) return;
 
-    if (Array.isArray(toValue(target))) {
-      toValue(target).forEach((element) => {
+    if (Array.isArray(targetValue.value)) {
+      targetValue.value.forEach((element) => {
         observer.observe(element, config);
       });
     } else {
-      observer.observe(toValue(target), config);
+      observer.observe(targetValue.value, config);
     }
   });
 
   watch(
-    () => toValue(target),
+    targetValue,
     () => {
-      if (Array.isArray(toValue(target))) {
-        toValue(target).forEach((element) => {
+      if (!targetValue.value) return;
+
+      if (Array.isArray(targetValue.value)) {
+        targetValue.value.forEach((element) => {
           observer.observe(element, config);
         });
 
         return;
       }
 
-      observer.observe(toValue(target), config);
+      observer.observe(targetValue.value, config);
     },
     {
       deep: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vueless",
-  "version": "0.0.478-beta.5",
+  "version": "0.0.478-beta.7",
   "license": "MIT",
   "description": "Vue Styleless UI Component Library, powered by Tailwind CSS.",
   "keywords": [
@@ -81,6 +81,7 @@
     "vite": "^5.4.9",
     "vite-plugin-compression": "^0.5.1",
     "vue": "^3.5.4",
+    "vue-i18n": "^10.0.4",
     "vue-router": "^4.3.2",
     "vue-tsc": "^2.1.6"
   },

package/types.ts

@@ -4,7 +4,10 @@ import { hasSlotContent } from "./composablesTs/useUI.ts";
 import UTextDefaultConfig from "./ui.text-block/config.ts";
 import UButtonDefaultConfig from "./ui.button/config.ts";
 import UBadgeDefaultConfig from "./ui.text-badge/config.ts";
-import type { ComputedRef } from "vue";
+
+import type { ComputedRef, MaybeRef } from "vue";
+
+export type TemplateRefElement = MaybeRef<HTMLElement | HTMLElement[] | null>;
 
 export interface ThemeConfig {
   /**

package/ui.button/storybook/stories.js

@@ -5,9 +5,6 @@ import UIcon from "../../ui.image-icon/UIcon.vue";
 import URow from "../../ui.container-row/URow.vue";
 import UCol from "../../ui.container-col/UCol.vue";
 
-/**
- * The `UButton` component. | [View on GitHub](https://github.com/vuelessjs/vueless/tree/main/src/ui.button)
- */
 export default {
   id: "1010",
   title: "Buttons & Links / Button",
@@ -18,6 +15,14 @@ export default {
   argTypes: {
     ...getArgTypes(UButton.__name),
   },
+  // TODO: Generate by function same like `getArgTypes(UButton.__name)`
+  parameters: {
+    docs: {
+      description: {
+        component: `The \`${UButton.__name}\` component. | [View on GitHub](https://github.com/vuelessjs/vueless/tree/main/src/ui.button)`,
+      },
+    },
+  },
 };
 
 const DefaultTemplate = (args) => ({

package/ui.text-badge/config.ts

@@ -63,7 +63,7 @@ export default /*tw*/ {
     round: false,
     bordered: false,
   },
-  safelist: (colors: string) => [
+  safelist: (colors) => [
     { pattern: `bg-(${colors})-50` },
     { pattern: `bg-(${colors})-600` },
     { pattern: `border-(${colors})-100` },

package/ui.text-badge/types.ts

@@ -14,7 +14,7 @@ export interface UBadgeProps {
   /**
    * Add border to the `thirdary` variant.
    */
-  bordered: boolean;
+  bordered?: boolean;
 
   /**
    * Badge size.
@@ -65,12 +65,12 @@ export interface UBadgeProps {
   /**
    * Set badge corners rounded.
    */
-  round: boolean;
+  round?: boolean;
 
   /**
    * Controls the keyboard “Tab” focus order of elements.
    */
-  tabindex: string;
+  tabindex?: string;
 
   /**
    * Component config object.

package/utils/utilStorybook.js

@@ -63,24 +63,12 @@ export function getArgTypes(componentName) {
     }
 
     if (type.includes("|")) {
-      const options = attribute.value.type.replace(/['|]/g, "").split(/\s+/);
-
-      if (options.length > 1) {
-        types[attribute.name] = {
-          options,
-          control: "select",
-          table: {
-            defaultValue: { summary: attribute.default || "" },
-          },
-        };
-      } else {
-        types[attribute.name] = {
-          control: type.split("|")[0],
-          table: {
-            defaultValue: { summary: attribute.default || "" },
-          },
-        };
-      }
+      types[attribute.name] = {
+        control: type.split("|")[0],
+        table: {
+          defaultValue: { summary: attribute.default || "" },
+        },
+      };
     }
 
     if (attribute.description?.includes("@ignore")) {
@@ -90,6 +78,17 @@ export function getArgTypes(componentName) {
         },
       };
     }
+
+    if (attribute.enum) {
+      types[attribute.name] = {
+        options: attribute.enum,
+        control: "select",
+        table: {
+          defaultValue: { summary: attribute.default || "" },
+          type: { summary: attribute.enum.join(" | ") },
+        },
+      };
+    }
   });
 
   component.slots?.forEach((slot) => {

package/utilsTs/utilStorybook.ts

@@ -27,6 +27,7 @@ interface Tag {
 
 interface Attribute {
   name: string;
+  enum: string[];
   required?: boolean;
   description?: string;
   value: AttributeValue;
@@ -97,6 +98,7 @@ interface TableConfig {
   disable?: boolean;
   defaultValue?: { summary: unknown };
   category?: "slots" | "expose" | "Storybook Events";
+  type?: Record<string, string | string[]>;
 }
 
 /* Load Web-Types from the project root. */
@@ -168,24 +170,23 @@ export function getArgTypes(componentName: string | undefined) {
     }
 
     if (type.includes("|")) {
-      const options = attribute.value.type.replace(/['|]/g, "").split(/\s+/);
-
-      if (options.length > 1) {
-        types[attribute.name] = {
-          options,
-          control: "select",
-          table: {
-            defaultValue: { summary: attribute.default || "" },
-          },
-        };
-      } else {
-        types[attribute.name] = {
-          control: type.split("|")[0] as ArgType["control"],
-          table: {
-            defaultValue: { summary: attribute.default || "" },
-          },
-        };
-      }
+      types[attribute.name] = {
+        control: type.split("|")[0] as ArgType["control"],
+        table: {
+          defaultValue: { summary: attribute.default || "" },
+        },
+      };
+    }
+
+    if (attribute.enum) {
+      types[attribute.name] = {
+        options: attribute.enum,
+        control: "select",
+        table: {
+          defaultValue: { summary: attribute.default || "" },
+          type: { summary: attribute.enum.join(" | ") },
+        },
+      };
     }
 
     if (attribute.description?.includes("@ignore")) {

package/adatper.locale/vue-i18n.js

@@ -1,11 +0,0 @@
-export default function createVueI18nAdapter(i18n) {
-  return {
-    name: "vue-i18n",
-    locale: i18n.global.locale,
-    fallback: i18n.global.fallbackLocale,
-    messages: i18n.global.messages,
-    t: (key, ...params) => i18n.global.t(key, params),
-    tm: i18n.global.tm,
-    n: i18n.global.n,
-  };
-}