@indielayer/ui 0.0.0-dev-20240125104319

package/lib/components/toggle/theme/Toggle.carbon.theme.d.ts

@@ -0,0 +1,3 @@
+import type { ToggleTheme } from '../Toggle.vue';
+declare const theme: ToggleTheme;
+export default theme;

package/lib/components/toggle/theme/Toggle.carbon.theme.js

@@ -0,0 +1,5 @@
+import e from "./Toggle.base.theme.js";
+const t = e, o = t;
+export {
+  o as default
+};

package/lib/components/tooltip/Tooltip.vue.d.ts

@@ -0,0 +1,13 @@
+import type { ExtractPublicPropTypes } from 'vue';
+declare const tooltipProps: {};
+export type TooltipProps = ExtractPublicPropTypes<typeof tooltipProps>;
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>, {
+    default?(_: {}): any;
+    tooltip?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/lib/components/tooltip/Tooltip.vue.js

@@ -0,0 +1,31 @@
+import { defineComponent as s, openBlock as r, createBlock as a, withCtx as t, createElementVNode as n, createVNode as l, renderSlot as o } from "vue";
+import c from "../popover/Popover.vue.js";
+import "../popover/Popover.vue2.js";
+import i from "../popover/PopoverContainer.vue.js";
+const m = { class: "dark" }, _ = { name: "XTooltip" }, k = /* @__PURE__ */ s({
+  ..._,
+  setup(p) {
+    return (e, d) => (r(), a(c, {
+      triggers: ["hover"],
+      class: "inline-block"
+    }, {
+      content: t(() => [
+        n("div", m, [
+          l(i, { class: "p-2 text-white text-sm w-max max-w-xs" }, {
+            default: t(() => [
+              o(e.$slots, "tooltip")
+            ]),
+            _: 3
+          })
+        ])
+      ]),
+      default: t(() => [
+        o(e.$slots, "default")
+      ]),
+      _: 3
+    }));
+  }
+});
+export {
+  k as default
+};

package/lib/components/tooltip/Tooltip.vue2.js

@@ -0,0 +1,4 @@
+import f from "./Tooltip.vue.js";
+export {
+  f as default
+};

package/lib/components/tooltip/__tests__/Tooltip.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/components/tooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { default as XTooltip } from './Tooltip.vue';
+export type { TooltipProps } from './Tooltip.vue';

package/lib/composables/index.d.ts

@@ -0,0 +1,7 @@
+export * from './keys';
+export * from './useCommon';
+export * from './useColors';
+export * from './useCSS';
+export * from './useInputtable';
+export * from './useInteractive';
+export * from './useNotifications';

package/lib/composables/keys.d.ts

@@ -0,0 +1,19 @@
+import type { InjectionKey, MaybeRef } from 'vue';
+import type { FormInjection } from '../components/form/Form.vue';
+import type { TabGroupInjection } from '../components/tab/TabGroup.vue';
+import type { ButtonGroupInjection } from '../components/button/ButtonGroup.vue';
+import type { NotificationInjection } from '../components/notifications/Notifications.vue';
+import type { IconInjection } from '../components/icon/Icon.vue';
+import type { FormGroupInjection } from '../components/formGroup';
+import type { AccordionProps } from '../components/accordion';
+import type { UIOptions } from '../create';
+import type { UITheme } from '../theme';
+export declare const injectOptionsKey: InjectionKey<UIOptions>;
+export declare const injectThemeKey: InjectionKey<MaybeRef<UITheme>>;
+export declare const injectTabGroupKey: InjectionKey<TabGroupInjection>;
+export declare const injectFormKey: InjectionKey<FormInjection>;
+export declare const injectFormGroupKey: InjectionKey<FormGroupInjection>;
+export declare const injectIconsKey: InjectionKey<IconInjection>;
+export declare const injectButtonGroupKey: InjectionKey<ButtonGroupInjection>;
+export declare const injectNotificationKey: InjectionKey<NotificationInjection>;
+export declare const injectAccordionKey: InjectionKey<AccordionProps>;

package/lib/composables/keys.js

@@ -0,0 +1,12 @@
+const o = Symbol(), t = Symbol(), n = Symbol(), c = Symbol(), e = Symbol(), y = Symbol(), i = Symbol(), m = Symbol(), s = Symbol();
+export {
+  s as injectAccordionKey,
+  i as injectButtonGroupKey,
+  e as injectFormGroupKey,
+  c as injectFormKey,
+  y as injectIconsKey,
+  m as injectNotificationKey,
+  o as injectOptionsKey,
+  n as injectTabGroupKey,
+  t as injectThemeKey
+};

package/lib/composables/useCSS.d.ts

@@ -0,0 +1,6 @@
+export interface CSSComposition {
+    get: (name: string, value: string, theme?: string, modifier?: string) => string;
+    variable: (name: string, theme?: string, modifier?: string) => string;
+    variables: (object: Record<string, string | object>, theme?: string, modifier?: string) => Record<string, string>;
+}
+export declare const useCSS: (namespace?: string) => CSSComposition;

package/lib/composables/useCSS.js

@@ -0,0 +1,26 @@
+const u = ["dark"], a = ["hover", "active", "focus", "visited"], f = (n) => u.includes(n), v = (n) => a.includes(n), d = (n) => {
+  const $ = (i, e, t, s) => `${r(i, t, s)}: ${e}`, r = (i, e, t) => `--x${n ? `-${n}` : ""}${e ? `-${e}` : ""}-${i}${t ? `-${t}` : ""}`, l = (i, e, t) => {
+    let s = {};
+    for (const o in i) {
+      const c = i[o];
+      if (!c)
+        break;
+      f(o) ? s = {
+        ...s,
+        ...l(c, o, t)
+      } : v(o) ? s = {
+        ...s,
+        ...l(c, e, o)
+      } : s[r(o, e, t)] = c;
+    }
+    return s;
+  };
+  return {
+    get: $,
+    variable: r,
+    variables: l
+  };
+};
+export {
+  d as useCSS
+};

package/lib/composables/useColors.d.ts

@@ -0,0 +1,32 @@
+export type Tone = '50' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900' | '950';
+export interface ColorPalette {
+    50: string;
+    100: string;
+    200: string;
+    300: string;
+    400: string;
+    500: string;
+    600: string;
+    700: string;
+    800: string;
+    900: string;
+    950: string;
+}
+export type ColorLibrary = Record<string, ColorPalette>;
+export interface ColorsProps {
+    color?: string;
+}
+export interface ColorComposition {
+    getPalette: (color?: string) => ColorPalette;
+    getColorOpacity: (color: string, opacity: number) => string;
+}
+export declare const useColors: {
+    (): ColorComposition;
+    props(defaultColor?: string): {
+        readonly color: {
+            readonly type: StringConstructor;
+            readonly default: string | undefined;
+        };
+    };
+};
+export type UseColorsProps = ReturnType<typeof useColors.props>;

package/lib/composables/useColors.js

@@ -0,0 +1,52 @@
+import { inject as m, computed as p, unref as f } from "vue";
+import { injectThemeKey as g } from "./keys.js";
+import { tailwindColors as n, setOpacity as l, isValidColor as d, colorShade as t } from "../common/colors.js";
+import { mergeRightDeep as y } from "../common/utils.js";
+const i = {}, C = {
+  primary: n.sky,
+  secondary: n.slate,
+  success: n.green,
+  warning: n.yellow,
+  error: n.red
+}, a = (r) => n[r], c = (r, s) => l(r, s), w = () => {
+  const r = m(g, {}), s = p(() => y(C, f(r).colors || {}));
+  return {
+    getPalette: (e) => {
+      if (!e)
+        return a("gray");
+      const o = a(e);
+      if (o)
+        return o;
+      if (i[e])
+        return i[e];
+      if (s.value[e])
+        return s.value[e];
+      if (!d(e))
+        return console.warn(`Invalid color: ${e}`), a("gray");
+      const u = {
+        50: t(e, 0.9),
+        100: t(e, 0.8),
+        200: t(e, 0.6),
+        300: t(e, 0.4),
+        400: t(e, 0.1),
+        500: e,
+        600: t(e, -0.1),
+        700: t(e, -0.25),
+        800: t(e, -0.58),
+        900: t(e, -0.7),
+        950: t(e, -0.8)
+      };
+      return i[e] = u, u;
+    },
+    getColorOpacity: c
+  };
+};
+w.props = (r) => ({
+  color: {
+    type: String,
+    default: r
+  }
+});
+export {
+  w as useColors
+};

package/lib/composables/useCommon.d.ts

@@ -0,0 +1,15 @@
+import type { PropType } from 'vue';
+export type Size = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export declare const useCommon: {
+    (): void;
+    props(): {
+        readonly size: {
+            readonly type: PropType<Size>;
+            readonly default: "md";
+            readonly validator: (value: string) => boolean;
+        };
+    };
+    validators(): {
+        size: string[];
+    };
+};

package/lib/composables/useCommon.js

@@ -0,0 +1,17 @@
+const e = () => {
+}, s = Object.freeze({
+  size: ["xs", "sm", "md", "lg", "xl"]
+});
+e.props = () => ({
+  size: {
+    type: String,
+    default: "md",
+    validator: (t) => s.size.includes(t)
+  }
+});
+e.validators = () => ({
+  ...s
+});
+export {
+  e as useCommon
+};

package/lib/composables/useFocusTrap.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentPublicInstance } from 'vue';
+import { type MaybeRef } from 'vue';
+export declare function useFocusTrap(): {
+    initFocusTrap: (targetRef: MaybeRef<HTMLElement | ComponentPublicInstance | null>) => Promise<void>;
+    clearFocusTrap: () => void;
+};

package/lib/composables/useFocusTrap.js

@@ -0,0 +1,45 @@
+import { onUnmounted as y, unref as p, nextTick as x } from "vue";
+const m = 'button:not([tabindex="-1"]), [href], input, select, textarea, li, a, [tabindex]:not([tabindex="-1"])';
+function w() {
+  let n = [], u = null, s = null, r = null;
+  async function b(e) {
+    e = p(e), e && (await x(), f(e), s && s.focus(), document.addEventListener("keydown", d), u = new MutationObserver(() => f(e)), e.$el ? u.observe(e.$el, { childList: !0, subtree: !0 }) : u.observe(e, { childList: !0, subtree: !0 }));
+  }
+  function f(e) {
+    if (e === null)
+      return;
+    let c;
+    e.$el ? c = e == null ? void 0 : e.$el.querySelectorAll(m) : e.querySelectorAll(m), n = Array.from(c || []), s = n[0] || null, r = n[n.length - 1] || null;
+  }
+  const d = (e) => {
+    var c;
+    if (e.key === "Tab") {
+      const t = e.shiftKey, o = document.activeElement;
+      if (!o) {
+        e.preventDefault(), (c = n[0]) == null || c.focus();
+        return;
+      }
+      const l = n[0], i = n[n.length - 1];
+      !t && o === i ? (e.preventDefault(), l == null || l.focus()) : t && o === l && (e.preventDefault(), i == null || i.focus());
+    } else if (e.key === "ArrowUp" || e.key === "ArrowLeft") {
+      e.preventDefault();
+      const t = document.activeElement, o = n.indexOf(t), l = n[o - 1];
+      l ? l.focus() : r && r.focus();
+    } else if (e.key === "ArrowDown" || e.key === "ArrowRight") {
+      e.preventDefault();
+      const t = document.activeElement, o = n.indexOf(t), l = n[o + 1];
+      l ? l.focus() : s && s.focus();
+    }
+  }, a = () => {
+    document.removeEventListener("keydown", d), u == null || u.disconnect();
+  };
+  return y(() => {
+    a();
+  }), {
+    initFocusTrap: b,
+    clearFocusTrap: a
+  };
+}
+export {
+  w as useFocusTrap
+};

package/lib/composables/useInputtable.d.ts

@@ -0,0 +1,50 @@
+import type { MaybeRef, PropType } from 'vue';
+export interface XFormInputMethods {
+    focus: () => void;
+    validate: (val: any) => boolean;
+    setError: (val: string) => void;
+}
+export declare const useInputtable: {
+    (props: any, { focus, emit, withListeners }: {
+        focus: () => void;
+        emit: any;
+        withListeners?: boolean | undefined;
+    }): {
+        isFirstValidation: import("vue").Ref<boolean>;
+        errorInternal: any;
+        hideFooterInternal: any;
+        isFocused: import("vue").Ref<boolean>;
+        isInsideForm: boolean;
+        isInsideFormGroup: boolean;
+        inputListeners: MaybeRef<{
+            focus: (event: Event) => void;
+            blur: (event: Event) => void;
+            input: (event: Event) => void;
+            change: (event: Event) => void;
+        }>;
+        formGroup: import("..").FormGroupInjection;
+        reset: () => void;
+        validate: (val?: any) => boolean;
+        setError: (val: string) => void;
+    };
+    emits(withListeners?: boolean): string[];
+    props(): {
+        readonly modelValue: PropType<string | number | boolean | object | any[] | undefined>;
+        readonly id: StringConstructor;
+        readonly name: StringConstructor;
+        readonly readonly: BooleanConstructor;
+        readonly required: BooleanConstructor;
+        readonly validateOnInput: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+        readonly label: StringConstructor;
+        readonly helper: StringConstructor;
+        readonly error: StringConstructor;
+        readonly hideFooter: BooleanConstructor;
+        readonly rules: {
+            readonly type: ArrayConstructor;
+            readonly default: () => never[];
+        };
+    };
+};

package/lib/composables/useInputtable.js

@@ -0,0 +1,110 @@
+import { ref as i, watch as h, inject as G, computed as j, onMounted as A, onUnmounted as O } from "vue";
+import { injectFormGroupKey as K, injectFormKey as M } from "./keys.js";
+const y = (r, { focus: I, emit: o, withListeners: b = !0 }) => {
+  const s = i(!0), n = i(r.error), v = i(r.hideFooter), V = r.name ? r.name : (Math.random() + 1).toString(36).substring(7), a = i(V);
+  h(() => r.error, (e) => {
+    n.value = e;
+  }), h(() => r.name, (e) => {
+    e && (a.value = e);
+  });
+  const t = G(K, {
+    registerInputGroup: () => {
+    },
+    unregisterInputGroup: () => {
+    },
+    setValue: () => {
+    },
+    isInsideFormGroup: !1,
+    value: void 0
+  });
+  t.isInsideFormGroup && (v.value = !0);
+  const c = G(M, {
+    registerInput: () => {
+    },
+    unregisterInput: () => {
+    },
+    isInsideForm: !1
+  }), S = () => {
+    n.value = "", s.value = !0, o("update:modelValue", "");
+  }, F = (e) => {
+    n.value = e;
+  }, m = (e) => {
+    e = e || r.modelValue, s.value = !1;
+    for (let p = 0; p < r.rules.length; p++) {
+      const u = r.rules[p];
+      let l = !0;
+      if (typeof u == "function")
+        l = u(e);
+      else if (Array.isArray(u) && u.length === 2) {
+        const { 0: d, 1: g } = u;
+        l = d(e, g);
+      } else {
+        const d = u.fn, { options: g } = u;
+        l = d(e, g);
+      }
+      if (l !== !0)
+        return n.value = l, !1;
+    }
+    return n.value = "", !0;
+  }, f = i(!1), B = b ? j(() => ({
+    focus: (e) => {
+      f.value = !0, o("focus", e);
+    },
+    blur: (e) => {
+      f.value = !1, o("blur", e);
+    },
+    input: (e) => {
+      r.validateOnInput && !s.value && m(e.target.value), o("update:modelValue", e.target.value);
+    },
+    change: (e) => o("change", e)
+  })) : {
+    focus: () => {
+    },
+    blur: () => {
+    },
+    input: () => {
+    },
+    change: () => {
+    }
+  };
+  return A(() => {
+    t.isInsideFormGroup ? t.registerInputGroup(a.value, I) : c.registerInput(a.value, I, m, F);
+  }), O(() => {
+    t.isInsideFormGroup ? t.unregisterInputGroup(a.value) : c.unregisterInput(a.value);
+  }), {
+    isFirstValidation: s,
+    errorInternal: n,
+    hideFooterInternal: v,
+    isFocused: f,
+    isInsideForm: c.isInsideForm,
+    isInsideFormGroup: t.isInsideFormGroup,
+    inputListeners: B,
+    formGroup: t,
+    reset: S,
+    validate: m,
+    setError: F
+  };
+};
+y.emits = (r = !0) => r ? ["update:modelValue", "blur", "focus", "input", "change"] : ["update:modelValue"];
+y.props = () => ({
+  modelValue: [String, Number, Boolean, Object, Array],
+  id: String,
+  name: String,
+  readonly: Boolean,
+  required: Boolean,
+  validateOnInput: {
+    type: Boolean,
+    default: !0
+  },
+  label: String,
+  helper: String,
+  error: String,
+  hideFooter: Boolean,
+  rules: {
+    type: Array,
+    default: () => []
+  }
+});
+export {
+  y as useInputtable
+};

package/lib/composables/useInteractive.d.ts

@@ -0,0 +1,23 @@
+import type { LoaderStatus } from 'src/components/loader/Loader.vue';
+import type { PropType, Ref } from 'vue';
+export interface InteractiveProps {
+    disabled?: boolean;
+    loading?: boolean;
+    loadingLabel?: string;
+    loadingStatus?: LoaderStatus;
+}
+export declare const useInteractive: {
+    (el: Ref<HTMLElement | null>): {
+        focus: () => void | undefined;
+        blur: () => void | undefined;
+    };
+    props(): {
+        readonly disabled: BooleanConstructor;
+        readonly loading: BooleanConstructor;
+        readonly loadingLabel: StringConstructor;
+        readonly loadingStatus: {
+            readonly type: PropType<LoaderStatus>;
+            readonly default: "active";
+        };
+    };
+};

package/lib/composables/useInteractive.js

@@ -0,0 +1,22 @@
+const t = (o) => ({
+  focus: () => {
+    var a, e;
+    return (e = (a = o.value) == null ? void 0 : a.focus) == null ? void 0 : e.call(a);
+  },
+  blur: () => {
+    var a, e;
+    return (e = (a = o.value) == null ? void 0 : a.blur) == null ? void 0 : e.call(a);
+  }
+});
+t.props = () => ({
+  disabled: Boolean,
+  loading: Boolean,
+  loadingLabel: String,
+  loadingStatus: {
+    type: String,
+    default: "active"
+  }
+});
+export {
+  t as useInteractive
+};

package/lib/composables/useNotifications.d.ts

@@ -0,0 +1,2 @@
+import type { NotificationInjection } from '../components/notifications/Notifications.vue';
+export declare const useNotifications: (key?: symbol | string) => NotificationInjection | undefined;

package/lib/composables/useNotifications.js

@@ -0,0 +1,9 @@
+import { inject as o } from "vue";
+import { injectNotificationKey as n } from "./keys.js";
+const a = (i) => {
+  const t = o(i || n);
+  return t || console.warn("useNotifications must have a parent wrapped with Notifications component"), t;
+};
+export {
+  a as useNotifications
+};

package/lib/composables/useTheme.d.ts

@@ -0,0 +1,29 @@
+import { type Slots, type UnwrapNestedRefs, type UnwrapRef, type MaybeRef, type CSSProperties } from 'vue';
+import { type ColorComposition } from './useColors';
+import { type CSSComposition } from './useCSS';
+import type { ComponentThemes } from 'src/theme';
+export type Stylish = false | null | undefined | string | CSSProperties;
+export type StyleValue = Stylish | Array<Stylish>;
+export type ThemeVueClass = string | Record<string, boolean> | (string | Record<string, boolean>)[];
+export type ThemeClasses<P, K extends string = string, D = undefined> = Record<K, string | ((params: ThemeParams<P, D>) => ThemeVueClass)>;
+export type ThemeStyles<P, D> = StyleValue | ((params: ThemeParams<P, D>) => StyleValue);
+export interface ThemeComponent<P = object, K extends string = string, D = object> {
+    classes?: Partial<ThemeClasses<P, K, D>>;
+    styles?: ThemeStyles<P, D>;
+}
+export type ThemeParams<P = Record<string, any>, D = Record<string, any>> = {
+    props: UnwrapRef<P>;
+    slots: Slots;
+    colors: ColorComposition;
+    css: CSSComposition;
+    rtl?: boolean;
+    data: UnwrapNestedRefs<D>;
+};
+export declare const useTheme: <P extends object = object, K extends string = string, D extends object = object>(namespace: keyof ComponentThemes, defaultTheme?: ThemeComponent<P, K, D>, props?: MaybeRef<P>, data?: D) => {
+    classPrefix: import("vue").ComputedRef<string>;
+    className: import("vue").ComputedRef<string>;
+    colors: ColorComposition;
+    classes: import("vue").ComputedRef<Record<K, ThemeVueClass>>;
+    styles: import("vue").ComputedRef<StyleValue>;
+    css: CSSComposition;
+};

package/lib/composables/useTheme.js

@@ -0,0 +1,59 @@
+import { inject as O, computed as c, unref as e, useSlots as P } from "vue";
+import { injectThemeKey as T } from "./keys.js";
+import { useColors as d } from "./useColors.js";
+import { useCSS as A } from "./useCSS.js";
+import { mergeRightDeep as D, smartUnref as h, isFunction as S, isObject as $ } from "../common/utils.js";
+const U = (s, r = {}, n = {}, l = {}) => {
+  const o = O(T, {}), v = c(() => {
+    var t, m, a;
+    return (m = (t = e(o)) == null ? void 0 : t.components) != null && m[s] ? D(r.classes || {}, ((a = e(o).components) == null ? void 0 : a[s].classes) || {}) : r.classes || {};
+  }), p = s.replace(/([A-Z])/g, (t) => `-${t[0].toLowerCase()}`).replace(/^-/, ""), f = c(() => {
+    var t;
+    return ((t = e(o)) == null ? void 0 : t.classPrefix) ?? "x-";
+  }), w = c(() => `${f.value}${p}`), C = c(() => {
+    var t;
+    return ((t = e(o)) == null ? void 0 : t.rtl) ?? !1;
+  }), g = P(), i = d(), u = A(p), y = c(() => b(v.value, {
+    props: e(n),
+    slots: g,
+    data: h(l),
+    colors: i,
+    css: u,
+    rtl: e(C)
+  })), N = c(() => {
+    var a, x;
+    const t = ((x = (a = e(o)) == null ? void 0 : a.components) == null ? void 0 : x[s]) || {}, m = {
+      props: e(n),
+      slots: g,
+      data: h(l),
+      colors: i,
+      css: u,
+      rtl: e(C)
+    };
+    return [
+      j(r.styles, m),
+      j(t.styles, m)
+    ];
+  });
+  return {
+    classPrefix: f,
+    className: w,
+    colors: i,
+    classes: y,
+    styles: N,
+    css: u
+  };
+};
+function b(s, r) {
+  const n = {};
+  return Object.keys(s).forEach((l) => {
+    const o = s[l];
+    n[l] = S(o) ? o(r) : $(o) ? b(o, r) : o;
+  }), n;
+}
+function j(s, r) {
+  return S(s) ? s(r) || {} : $(s) ? s : {};
+}
+export {
+  U as useTheme
+};

package/lib/create.d.ts

@@ -0,0 +1,12 @@
+import type { App } from 'vue';
+import { type UITheme } from './theme';
+export type UIOptions = {
+    prefix?: string;
+    components?: any[];
+    icons?: Record<string, any>;
+    theme?: UITheme;
+};
+declare const create: (createOptions?: UIOptions) => {
+    install: (app: App, installOptions?: UIOptions) => void;
+};
+export default create;

package/lib/create.js

@@ -0,0 +1,21 @@
+import { injectOptionsKey as r, injectIconsKey as m, injectThemeKey as f } from "./composables/keys.js";
+import { injectThemeStyles as a } from "./theme.js";
+const l = {
+  prefix: "X"
+}, h = (o = {}) => ({
+  install: (t, c = {}) => {
+    var s;
+    const e = {
+      ...l,
+      ...o,
+      ...c
+    };
+    e.components && e.components.forEach((n) => {
+      const i = n.name.startsWith("X") ? n.name.slice(1) : n.name;
+      t.component(`${e.prefix}${i}`) || t.component(`${e.prefix}${i}`, n);
+    }), t.provide(r, e), t.provide(m, e.icons || {}), t.provide(f, e.theme || {}), (s = e.theme) != null && s.styles && a(e.theme.name || "", e.theme.styles);
+  }
+}), $ = h;
+export {
+  $ as default
+};