@nuxt/ui 2.18.3 → 3.0.0-alpha.0

package/dist/runtime/components/overlays/Tooltip.vue.d.ts

@@ -1,165 +0,0 @@
-import type { PropType } from 'vue';
-import type { PopperOptions, Strategy } from '../../types.js';
-declare const config: {
-    wrapper: string;
-    container: string;
-    width: string;
-    background: string;
-    color: string;
-    shadow: string;
-    rounded: string;
-    ring: string;
-    base: string;
-    shortcuts: string;
-    middot: string;
-    transition: {
-        enterActiveClass: string;
-        enterFromClass: string;
-        enterToClass: string;
-        leaveActiveClass: string;
-        leaveFromClass: string;
-        leaveToClass: string;
-    };
-    popper: {
-        strategy: string;
-    };
-    default: {
-        openDelay: number;
-        closeDelay: number;
-    };
-    arrow: {
-        base: string;
-        ring: string;
-        rounded: string;
-        background: string;
-        shadow: string;
-        placement: string;
-    };
-};
-declare const _default: import("vue").DefineComponent<{
-    text: {
-        type: StringConstructor;
-        default: any;
-    };
-    prevent: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    shortcuts: {
-        type: PropType<string[]>;
-        default: () => any[];
-    };
-    openDelay: {
-        type: NumberConstructor;
-        default: () => number;
-    };
-    closeDelay: {
-        type: NumberConstructor;
-        default: () => number;
-    };
-    popper: {
-        type: PropType<PopperOptions>;
-        default: () => {};
-    };
-    class: {
-        type: PropType<any>;
-        default: () => string;
-    };
-    ui: {
-        type: PropType<Partial<typeof config> & {
-            strategy?: Strategy;
-        }>;
-        default: () => {};
-    };
-}, {
-    ui: import("vue").ComputedRef<{
-        wrapper: string;
-        container: string;
-        width: string;
-        background: string;
-        color: string;
-        shadow: string;
-        rounded: string;
-        ring: string;
-        base: string;
-        shortcuts: string;
-        middot: string;
-        transition: {
-            enterActiveClass: string;
-            enterFromClass: string;
-            enterToClass: string;
-            leaveActiveClass: string;
-            leaveFromClass: string;
-            leaveToClass: string;
-        };
-        popper: {
-            strategy: string;
-        };
-        default: {
-            openDelay: number;
-            closeDelay: number;
-        };
-        arrow: {
-            base: string;
-            ring: string;
-            rounded: string;
-            background: string;
-            shadow: string;
-            placement: string;
-        };
-    }>;
-    attrs: import("vue").ComputedRef<Pick<{
-        [x: string]: unknown;
-    }, string>>;
-    popper: import("vue").ComputedRef<PopperOptions>;
-    trigger: import("vue").Ref<import("@vueuse/core").MaybeElement>;
-    container: import("vue").Ref<import("@vueuse/core").MaybeElement>;
-    open: import("vue").Ref<boolean>;
-    onMouseEnter: () => void;
-    onMouseLeave: () => void;
-}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    text: {
-        type: StringConstructor;
-        default: any;
-    };
-    prevent: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
-    shortcuts: {
-        type: PropType<string[]>;
-        default: () => any[];
-    };
-    openDelay: {
-        type: NumberConstructor;
-        default: () => number;
-    };
-    closeDelay: {
-        type: NumberConstructor;
-        default: () => number;
-    };
-    popper: {
-        type: PropType<PopperOptions>;
-        default: () => {};
-    };
-    class: {
-        type: PropType<any>;
-        default: () => string;
-    };
-    ui: {
-        type: PropType<Partial<typeof config> & {
-            strategy?: Strategy;
-        }>;
-        default: () => {};
-    };
-}>>, {
-    class: any;
-    popper: PopperOptions;
-    text: string;
-    ui: {};
-    openDelay: number;
-    closeDelay: number;
-    shortcuts: string[];
-    prevent: boolean;
-}, {}>;
-export default _default;

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

@@ -1,2 +0,0 @@
-import { type Ref } from 'vue';
-export declare const useCarouselScroll: (el: Ref<HTMLElement>) => void;

package/dist/runtime/composables/useCarouselScroll.js

@@ -1,37 +0,0 @@
-import { ref, onMounted, onUnmounted } from "vue";
-export const useCarouselScroll = (el) => {
-  const x = ref(0);
-  function onMouseDown(e) {
-    el.value.style.scrollSnapType = "none";
-    el.value.style.scrollBehavior = "auto";
-    x.value = e.pageX;
-    window.addEventListener("mousemove", onMouseMove);
-    window.addEventListener("mouseup", onMouseUp);
-  }
-  function onMouseUp() {
-    el.value.style.removeProperty("scroll-behavior");
-    el.value.style.removeProperty("scroll-snap-type");
-    el.value.style.removeProperty("pointer-events");
-    window.removeEventListener("mousemove", onMouseMove);
-    window.removeEventListener("mouseup", onMouseUp);
-  }
-  function onMouseMove(e) {
-    e.preventDefault();
-    el.value.style.pointerEvents = "none";
-    const delta = e.pageX - x.value;
-    x.value = e.pageX;
-    el.value.scrollBy(-delta, 0);
-  }
-  onMounted(() => {
-    if (!el.value) {
-      return;
-    }
-    el.value.addEventListener("mousedown", onMouseDown);
-  });
-  onUnmounted(() => {
-    if (!el.value) {
-      return;
-    }
-    el.value.removeEventListener("mousedown", onMouseDown);
-  });
-};

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

@@ -1,10 +0,0 @@
-import type { Notification } from '../types/notification.js';
-export declare function useCopyToClipboard(options?: Partial<Notification>): {
-    copy: (text: string, success?: {
-        title?: string;
-        description?: string;
-    }, failure?: {
-        title?: string;
-        description?: string;
-    }) => void;
-};

package/dist/runtime/composables/useCopyToClipboard.js

@@ -1,26 +0,0 @@
-import { useClipboard } from "@vueuse/core";
-import { useToast } from "./useToast.js";
-export function useCopyToClipboard(options = {}) {
-  const { copy: copyToClipboard, isSupported } = useClipboard();
-  const toast = useToast();
-  function copy(text, success = {}, failure = {}) {
-    if (!isSupported) {
-      return;
-    }
-    copyToClipboard(text).then(() => {
-      if (!success.title && !success.description) {
-        return;
-      }
-      toast.add({ ...success, ...options });
-    }, function(e) {
-      toast.add({
-        ...failure,
-        description: failure.description || e.message,
-        ...options
-      });
-    });
-  }
-  return {
-    copy
-  };
-}

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

@@ -1,18 +0,0 @@
-type InputProps = {
-    id?: string;
-    size?: string | number | symbol;
-    color?: string;
-    name?: string;
-    eagerValidation?: boolean;
-    legend?: string | null;
-};
-export declare const useFormGroup: (inputProps?: InputProps, config?: any) => {
-    inputId: import("vue").ComputedRef<string>;
-    name: import("vue").ComputedRef<string>;
-    size: import("vue").ComputedRef<string | number | symbol>;
-    color: import("vue").ComputedRef<string>;
-    emitFormBlur: () => void;
-    emitFormInput: import("@vueuse/shared").PromisifyFn<() => void>;
-    emitFormChange: () => void;
-};
-export {};

package/dist/runtime/composables/useFormGroup.js

@@ -1,49 +0,0 @@
-import { inject, ref, computed } from "vue";
-import { useDebounceFn } from "@vueuse/core";
-import { mergeConfig } from "../utils/index.js";
-import appConfig from "#build/app.config";
-import { formGroup } from "#ui/ui.config";
-const formGroupConfig = mergeConfig(appConfig.ui.strategy, appConfig.ui.formGroup, formGroup);
-export const useFormGroup = (inputProps, config) => {
-  const formBus = inject("form-events", void 0);
-  const formGroup2 = inject("form-group", void 0);
-  const formInputs = inject("form-inputs", void 0);
-  if (formGroup2) {
-    if (inputProps?.id) {
-      formGroup2.inputId.value = inputProps?.id;
-    }
-    if (formInputs) {
-      formInputs.value[formGroup2.name.value] = formGroup2.inputId.value;
-    }
-  }
-  const blurred = ref(false);
-  function emitFormEvent(type, path) {
-    if (formBus) {
-      formBus.emit({ type, path });
-    }
-  }
-  function emitFormBlur() {
-    emitFormEvent("blur", formGroup2?.name.value);
-    blurred.value = true;
-  }
-  function emitFormChange() {
-    emitFormEvent("change", formGroup2?.name.value);
-  }
-  const emitFormInput = useDebounceFn(() => {
-    if (blurred.value || formGroup2?.eagerValidation.value) {
-      emitFormEvent("input", formGroup2?.name.value);
-    }
-  }, 300);
-  return {
-    inputId: computed(() => inputProps?.id ?? formGroup2?.inputId.value),
-    name: computed(() => inputProps?.name ?? formGroup2?.name.value),
-    size: computed(() => {
-      const formGroupSize = config.size[formGroup2?.size.value] ? formGroup2?.size.value : null;
-      return inputProps?.size ?? formGroupSize ?? formGroupConfig?.default?.size;
-    }),
-    color: computed(() => formGroup2?.error?.value ? "red" : inputProps?.color),
-    emitFormBlur,
-    emitFormInput,
-    emitFormChange
-  };
-};

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

@@ -1,268 +0,0 @@
-import type { Ref } from 'vue';
-import type { VirtualElement } from '@popperjs/core/lib/popper-lite';
-import type { Instance } from '@popperjs/core';
-import type { MaybeElement } from '@vueuse/core';
-import type { PopperOptions } from '../types/popper.js';
-export declare const createPopper: <TModifier extends Partial<import("@popperjs/core").Modifier<any, any>>>(reference: Element | VirtualElement, popper: HTMLElement, options?: Partial<import("@popperjs/core").OptionsGeneric<TModifier>>) => Instance;
-export declare function usePopper({ locked, overflowPadding, offsetDistance, offsetSkid, gpuAcceleration, adaptive, scroll, resize, arrow, placement, strategy }: PopperOptions, virtualReference?: Ref<Element | VirtualElement>): readonly [Ref<MaybeElement>, Ref<MaybeElement>, Ref<{
-    state: {
-        elements: {
-            reference: Element | {
-                getBoundingClientRect: () => ClientRect | DOMRect;
-                contextElement?: Element;
-            };
-            popper: HTMLElement;
-            arrow?: HTMLElement;
-        };
-        options: {
-            placement: import("@popperjs/core").Placement;
-            modifiers: any[];
-            strategy: import("@popperjs/core").PositioningStrategy;
-            onFirstUpdate?: (arg0: Partial<import("@popperjs/core").State>) => void;
-        };
-        placement: import("@popperjs/core").Placement;
-        strategy: import("@popperjs/core").PositioningStrategy;
-        orderedModifiers: {
-            name: any;
-            enabled: boolean;
-            phase: import("@popperjs/core").ModifierPhases;
-            requires?: Array<string>;
-            requiresIfExists?: Array<string>;
-            fn: (arg0: import("@popperjs/core").ModifierArguments<any>) => import("@popperjs/core").State | void;
-            effect?: (arg0: import("@popperjs/core").ModifierArguments<any>) => (() => void) | void;
-            options?: Partial<any>;
-            data?: import("@popperjs/core").Obj;
-        }[];
-        rects: {
-            reference: {
-                width: number;
-                height: number;
-                x: number;
-                y: number;
-            };
-            popper: {
-                width: number;
-                height: number;
-                x: number;
-                y: number;
-            };
-        };
-        scrollParents: {
-            reference: (Element | {
-                innerHeight: number;
-                offsetHeight: number;
-                innerWidth: number;
-                offsetWidth: number;
-                pageXOffset: number;
-                pageYOffset: number;
-                getComputedStyle: typeof getComputedStyle;
-                addEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
-                removeEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
-                Element: Element;
-                HTMLElement: HTMLElement;
-                Node: Node;
-                toString: () => "[object Window]";
-                devicePixelRatio: number;
-                visualViewport?: {
-                    addEventListener: {
-                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
-                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
-                    };
-                    dispatchEvent: {
-                        (event: Event): boolean;
-                        (event: Event): boolean;
-                    };
-                    removeEventListener: {
-                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-                    };
-                    width: number;
-                    height: number;
-                    offsetLeft: number;
-                    offsetTop: number;
-                    scale: number;
-                };
-                ShadowRoot: ShadowRoot;
-            } | {
-                addEventListener: {
-                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
-                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
-                };
-                dispatchEvent: {
-                    (event: Event): boolean;
-                    (event: Event): boolean;
-                };
-                removeEventListener: {
-                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-                };
-                width: number;
-                height: number;
-                offsetLeft: number;
-                offsetTop: number;
-                scale: number;
-            })[];
-            popper: (Element | {
-                innerHeight: number;
-                offsetHeight: number;
-                innerWidth: number;
-                offsetWidth: number;
-                pageXOffset: number;
-                pageYOffset: number;
-                getComputedStyle: typeof getComputedStyle;
-                addEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
-                removeEventListener: (type: any, listener: any, optionsOrUseCapture?: any) => void;
-                Element: Element;
-                HTMLElement: HTMLElement;
-                Node: Node;
-                toString: () => "[object Window]";
-                devicePixelRatio: number;
-                visualViewport?: {
-                    addEventListener: {
-                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
-                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
-                    };
-                    dispatchEvent: {
-                        (event: Event): boolean;
-                        (event: Event): boolean;
-                    };
-                    removeEventListener: {
-                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-                        (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-                    };
-                    width: number;
-                    height: number;
-                    offsetLeft: number;
-                    offsetTop: number;
-                    scale: number;
-                };
-                ShadowRoot: ShadowRoot;
-            } | {
-                addEventListener: {
-                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
-                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
-                };
-                dispatchEvent: {
-                    (event: Event): boolean;
-                    (event: Event): boolean;
-                };
-                removeEventListener: {
-                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-                    (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
-                };
-                width: number;
-                height: number;
-                offsetLeft: number;
-                offsetTop: number;
-                scale: number;
-            })[];
-        };
-        styles: {
-            [key: string]: Partial<CSSStyleDeclaration>;
-        };
-        attributes: {
-            [key: string]: {
-                [key: string]: string | boolean;
-            };
-        };
-        modifiersData: {
-            [x: string]: any;
-            arrow?: {
-                x?: number;
-                y?: number;
-                centerOffset: number;
-            };
-            hide?: {
-                isReferenceHidden: boolean;
-                hasPopperEscaped: boolean;
-                referenceClippingOffsets: {
-                    top: number;
-                    left: number;
-                    right: number;
-                    bottom: number;
-                };
-                popperEscapeOffsets: {
-                    top: number;
-                    left: number;
-                    right: number;
-                    bottom: number;
-                };
-            };
-            offset?: {
-                "bottom-end"?: {
-                    y: number;
-                    x: number;
-                };
-                "bottom-start"?: {
-                    y: number;
-                    x: number;
-                };
-                bottom?: {
-                    y: number;
-                    x: number;
-                };
-                left?: {
-                    y: number;
-                    x: number;
-                };
-                right?: {
-                    y: number;
-                    x: number;
-                };
-                top?: {
-                    y: number;
-                    x: number;
-                };
-                auto?: {
-                    y: number;
-                    x: number;
-                };
-                "auto-start"?: {
-                    y: number;
-                    x: number;
-                };
-                "auto-end"?: {
-                    y: number;
-                    x: number;
-                };
-                "top-start"?: {
-                    y: number;
-                    x: number;
-                };
-                "top-end"?: {
-                    y: number;
-                    x: number;
-                };
-                "right-start"?: {
-                    y: number;
-                    x: number;
-                };
-                "right-end"?: {
-                    y: number;
-                    x: number;
-                };
-                "left-start"?: {
-                    y: number;
-                    x: number;
-                };
-                "left-end"?: {
-                    y: number;
-                    x: number;
-                };
-            };
-            preventOverflow?: {
-                y: number;
-                x: number;
-            };
-            popperOffsets?: {
-                y: number;
-                x: number;
-            };
-        };
-        reset: boolean;
-    };
-    destroy: () => void;
-    forceUpdate: () => void;
-    update: () => Promise<Partial<import("@popperjs/core").State>>;
-    setOptions: (setOptionsAction: Partial<import("@popperjs/core").OptionsGeneric<any>> | ((prev: Partial<import("@popperjs/core").OptionsGeneric<any>>) => Partial<import("@popperjs/core").OptionsGeneric<any>>)) => Promise<Partial<import("@popperjs/core").State>>;
-}>];

package/dist/runtime/composables/usePopper.js

@@ -1,94 +0,0 @@
-import { ref, onMounted, watchEffect } from "vue";
-import { popperGenerator, defaultModifiers } from "@popperjs/core/lib/popper-lite";
-import flip from "@popperjs/core/lib/modifiers/flip";
-import offset from "@popperjs/core/lib/modifiers/offset";
-import preventOverflow from "@popperjs/core/lib/modifiers/preventOverflow";
-import computeStyles from "@popperjs/core/lib/modifiers/computeStyles";
-import eventListeners from "@popperjs/core/lib/modifiers/eventListeners";
-import arrowModifier from "@popperjs/core/lib/modifiers/arrow";
-import { unrefElement } from "@vueuse/core";
-export const createPopper = popperGenerator({
-  defaultModifiers: [...defaultModifiers, offset, flip, preventOverflow, computeStyles, eventListeners, arrowModifier]
-});
-export function usePopper({
-  locked = false,
-  overflowPadding = 8,
-  offsetDistance = 8,
-  offsetSkid = 0,
-  gpuAcceleration = true,
-  adaptive = true,
-  scroll = true,
-  resize = true,
-  arrow = false,
-  placement,
-  strategy
-}, virtualReference) {
-  const reference = ref(null);
-  const popper = ref(null);
-  const instance = ref(null);
-  onMounted(() => {
-    watchEffect((onInvalidate) => {
-      if (!popper.value) {
-        return;
-      }
-      if (!reference.value && !virtualReference?.value) {
-        return;
-      }
-      const popperEl = unrefElement(popper);
-      const referenceEl = virtualReference?.value || unrefElement(reference);
-      if (!(popperEl instanceof HTMLElement)) {
-        return;
-      }
-      if (!referenceEl) {
-        return;
-      }
-      const config = {
-        modifiers: [
-          {
-            name: "flip",
-            enabled: !locked
-          },
-          {
-            name: "preventOverflow",
-            options: {
-              padding: overflowPadding
-            }
-          },
-          {
-            name: "offset",
-            options: {
-              offset: [offsetSkid, offsetDistance]
-            }
-          },
-          {
-            name: "computeStyles",
-            options: {
-              adaptive,
-              gpuAcceleration
-            }
-          },
-          {
-            name: "eventListeners",
-            options: {
-              scroll,
-              resize
-            }
-          },
-          {
-            name: "arrow",
-            enabled: arrow
-          }
-        ]
-      };
-      if (placement) {
-        config.placement = placement;
-      }
-      if (strategy) {
-        config.strategy = strategy;
-      }
-      instance.value = createPopper(referenceEl, popperEl, config);
-      onInvalidate(instance.value.destroy);
-    });
-  });
-  return [reference, popper, instance];
-}

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

@@ -1,12 +0,0 @@
-export declare const _useShortcuts: () => {
-    macOS: import("vue").ComputedRef<RegExpMatchArray>;
-    metaSymbol: import("vue").Ref<string>;
-    activeElement: import("vue").Ref<HTMLElement>;
-    usingInput: import("vue").ComputedRef<string | boolean>;
-};
-export declare const useShortcuts: () => {
-    macOS: import("vue").ComputedRef<RegExpMatchArray>;
-    metaSymbol: import("vue").Ref<string>;
-    activeElement: import("vue").Ref<HTMLElement>;
-    usingInput: import("vue").ComputedRef<string | boolean>;
-};