@nuxt/ui 0.4.1 → 2.8.1

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

@@ -0,0 +1,82 @@
+/// <reference types="lodash" />
+import type { PropType } from 'vue';
+import type { PopperOptions } from '../../types/popper';
+declare const _default: import("vue").DefineComponent<{
+    text: {
+        type: StringConstructor;
+        default: null;
+    };
+    prevent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    shortcuts: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    closeDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    popper: {
+        type: PropType<PopperOptions>;
+        default: () => {};
+    };
+    ui: {
+        type: PropType<any>;
+        default: () => {};
+    };
+}, {
+    attrs: import("lodash").Omit<{
+        [x: string]: unknown;
+    }, "class">;
+    ui: import("vue").ComputedRef<any>;
+    trigger: import("vue").Ref<import("@vueuse/core").MaybeElement>;
+    container: import("vue").Ref<import("@vueuse/core").MaybeElement>;
+    open: import("vue").Ref<boolean>;
+    wrapperClass: import("vue").ComputedRef<string>;
+    onMouseOver: () => void;
+    onMouseLeave: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    text: {
+        type: StringConstructor;
+        default: null;
+    };
+    prevent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    shortcuts: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    closeDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    popper: {
+        type: PropType<PopperOptions>;
+        default: () => {};
+    };
+    ui: {
+        type: PropType<any>;
+        default: () => {};
+    };
+}>>, {
+    ui: any;
+    popper: PopperOptions;
+    text: string;
+    openDelay: number;
+    closeDelay: number;
+    prevent: boolean;
+    shortcuts: string[];
+}, {}>;
+export default _default;

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

@@ -0,0 +1,13 @@
+import type { WatchSource } from 'vue';
+export interface ShortcutConfig {
+    handler: Function;
+    usingInput?: string | boolean;
+    whenever?: WatchSource<Boolean>[];
+}
+export interface ShortcutsConfig {
+    [key: string]: ShortcutConfig | Function;
+}
+export interface ShortcutsOptions {
+    chainDelay?: number;
+}
+export declare const defineShortcuts: (config: ShortcutsConfig, options?: ShortcutsOptions) => void;

package/dist/runtime/composables/defineShortcuts.mjs

@@ -0,0 +1,108 @@
+import { ref, computed } from "vue";
+import { logicAnd, logicNot } from "@vueuse/math";
+import { useEventListener, useDebounceFn } from "@vueuse/core";
+import { useShortcuts } from "./useShortcuts.mjs";
+export const defineShortcuts = (config, options = {}) => {
+  const { macOS, usingInput } = useShortcuts();
+  let shortcuts = [];
+  const chainedInputs = ref([]);
+  const clearChainedInput = () => {
+    chainedInputs.value.splice(0, chainedInputs.value.length);
+  };
+  const debouncedClearChainedInput = useDebounceFn(clearChainedInput, options.chainDelay ?? 800);
+  const onKeyDown = (e) => {
+    if (!e.key) {
+      return;
+    }
+    const alphabeticalKey = /^[a-z]{1}$/i.test(e.key);
+    let chainedKey;
+    chainedInputs.value.push(e.key);
+    if (chainedInputs.value.length >= 2) {
+      chainedKey = chainedInputs.value.slice(-2).join("-");
+      for (const shortcut of shortcuts.filter((s) => s.chained)) {
+        if (shortcut.key !== chainedKey) {
+          continue;
+        }
+        if (shortcut.condition.value) {
+          e.preventDefault();
+          shortcut.handler();
+        }
+        clearChainedInput();
+        return;
+      }
+    }
+    for (const shortcut of shortcuts.filter((s) => !s.chained)) {
+      if (e.key.toLowerCase() !== shortcut.key) {
+        continue;
+      }
+      if (e.metaKey !== shortcut.metaKey) {
+        continue;
+      }
+      if (e.ctrlKey !== shortcut.ctrlKey) {
+        continue;
+      }
+      if (alphabeticalKey && e.shiftKey !== shortcut.shiftKey) {
+        continue;
+      }
+      if (shortcut.condition.value) {
+        e.preventDefault();
+        shortcut.handler();
+      }
+      clearChainedInput();
+      return;
+    }
+    debouncedClearChainedInput();
+  };
+  shortcuts = Object.entries(config).map(([key, shortcutConfig]) => {
+    if (!shortcutConfig) {
+      return null;
+    }
+    let shortcut;
+    if (key.includes("-") && key.includes("_")) {
+      console.trace("[Shortcut] Invalid key");
+      return null;
+    }
+    const chained = key.includes("-");
+    if (chained) {
+      shortcut = {
+        key: key.toLowerCase(),
+        metaKey: false,
+        ctrlKey: false,
+        shiftKey: false,
+        altKey: false
+      };
+    } else {
+      const keySplit = key.toLowerCase().split("_").map((k) => k);
+      shortcut = {
+        key: keySplit.filter((k) => !["meta", "ctrl", "shift", "alt"].includes(k)).join("_"),
+        metaKey: keySplit.includes("meta"),
+        ctrlKey: keySplit.includes("ctrl"),
+        shiftKey: keySplit.includes("shift"),
+        altKey: keySplit.includes("alt")
+      };
+    }
+    shortcut.chained = chained;
+    if (!macOS.value && shortcut.metaKey && !shortcut.ctrlKey) {
+      shortcut.metaKey = false;
+      shortcut.ctrlKey = true;
+    }
+    if (typeof shortcutConfig === "function") {
+      shortcut.handler = shortcutConfig;
+    } else if (typeof shortcutConfig === "object") {
+      shortcut = { ...shortcut, handler: shortcutConfig.handler };
+    }
+    if (!shortcut.handler) {
+      console.trace("[Shortcut] Invalid value");
+      return null;
+    }
+    const conditions = [];
+    if (!shortcutConfig.usingInput) {
+      conditions.push(logicNot(usingInput));
+    } else if (typeof shortcutConfig.usingInput === "string") {
+      conditions.push(computed(() => usingInput.value === shortcutConfig.usingInput));
+    }
+    shortcut.condition = logicAnd(...conditions, ...shortcutConfig.whenever || []);
+    return shortcut;
+  }).filter(Boolean);
+  useEventListener("keydown", onKeyDown);
+};

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

@@ -0,0 +1,10 @@
+import type { Notification } from '../types/notification';
+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.mjs

@@ -0,0 +1,26 @@
+import { useClipboard } from "@vueuse/core";
+import { useToast } from "./useToast.mjs";
+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

@@ -0,0 +1,6 @@
+export declare const useFormGroup: () => {
+    emitFormBlur: () => void;
+    emitFormInput: import("@vueuse/shared").PromisifyFn<() => void>;
+    emitFormChange: () => void;
+    formGroup: undefined;
+};

package/dist/runtime/composables/useFormGroup.mjs

@@ -0,0 +1,30 @@
+import { inject, ref } from "vue";
+import { useDebounceFn } from "@vueuse/core";
+export const useFormGroup = () => {
+  const formBus = inject("form-events", void 0);
+  const formGroup = inject("form-group", void 0);
+  const blurred = ref(false);
+  function emitFormEvent(type, path) {
+    if (formBus) {
+      formBus.emit({ type, path });
+    }
+  }
+  function emitFormBlur() {
+    emitFormEvent("blur", formGroup?.name.value);
+    blurred.value = true;
+  }
+  function emitFormChange() {
+    emitFormEvent("change", formGroup?.name.value);
+  }
+  const emitFormInput = useDebounceFn(() => {
+    if (blurred.value) {
+      emitFormEvent("input", formGroup?.name.value);
+    }
+  }, 300);
+  return {
+    emitFormBlur,
+    emitFormInput,
+    emitFormChange,
+    formGroup
+  };
+};

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

@@ -0,0 +1,232 @@
+import type { Ref } from 'vue';
+import { VirtualElement } from '@popperjs/core/lib/popper-lite';
+import type { Instance } from '@popperjs/core';
+import { MaybeElement } from '@vueuse/core';
+import type { PopperOptions } from '../types/popper';
+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>> | undefined) => Instance;
+export declare function usePopper({ locked, overflowPadding, offsetDistance, offsetSkid, gpuAcceleration, adaptive, scroll, resize, placement, strategy }: PopperOptions, virtualReference?: Ref<Element | VirtualElement>): readonly [Ref<MaybeElement>, Ref<MaybeElement>, Ref<{
+    state: {
+        elements: {
+            reference: Element | {
+                getBoundingClientRect: () => ClientRect | DOMRect;
+                contextElement?: Element | undefined;
+            };
+            popper: HTMLElement;
+            arrow?: HTMLElement | undefined;
+        };
+        options: {
+            placement: import("@popperjs/core").Placement;
+            modifiers: any[];
+            strategy: import("@popperjs/core").PositioningStrategy;
+            onFirstUpdate?: ((arg0: Partial<import("@popperjs/core").State>) => void) | undefined;
+        };
+        placement: import("@popperjs/core").Placement;
+        strategy: import("@popperjs/core").PositioningStrategy;
+        orderedModifiers: {
+            name: any;
+            enabled: boolean;
+            phase: import("@popperjs/core").ModifierPhases;
+            requires?: string[] | undefined;
+            requiresIfExists?: string[] | undefined;
+            fn: (arg0: import("@popperjs/core").ModifierArguments<any>) => void | import("@popperjs/core").State;
+            effect?: ((arg0: import("@popperjs/core").ModifierArguments<any>) => void | (() => void)) | undefined;
+            options?: Partial<any> | undefined;
+            data?: import("@popperjs/core").Obj | undefined;
+        }[];
+        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?: boolean | AddEventListenerOptions | undefined) => void;
+                    dispatchEvent: (event: Event) => boolean;
+                    removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                    width: number;
+                    height: number;
+                    offsetLeft: number;
+                    offsetTop: number;
+                    scale: number;
+                } | undefined;
+                ShadowRoot: ShadowRoot;
+            } | {
+                addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+                dispatchEvent: (event: Event) => boolean;
+                removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => 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?: boolean | AddEventListenerOptions | undefined) => void;
+                    dispatchEvent: (event: Event) => boolean;
+                    removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => void;
+                    width: number;
+                    height: number;
+                    offsetLeft: number;
+                    offsetTop: number;
+                    scale: number;
+                } | undefined;
+                ShadowRoot: ShadowRoot;
+            } | {
+                addEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions | undefined) => void;
+                dispatchEvent: (event: Event) => boolean;
+                removeEventListener: (type: string, callback: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions | undefined) => 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 | undefined;
+                y?: number | undefined;
+                centerOffset: number;
+            } | undefined;
+            hide?: {
+                isReferenceHidden: boolean;
+                hasPopperEscaped: boolean;
+                referenceClippingOffsets: {
+                    top: number;
+                    left: number;
+                    right: number;
+                    bottom: number;
+                };
+                popperEscapeOffsets: {
+                    top: number;
+                    left: number;
+                    right: number;
+                    bottom: number;
+                };
+            } | undefined;
+            offset?: {
+                "bottom-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "bottom-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                auto?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "auto-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "auto-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                top?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                bottom?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                right?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                left?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "top-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "top-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "right-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "right-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "left-start"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+                "left-end"?: {
+                    y: number;
+                    x: number;
+                } | undefined;
+            } | undefined;
+            preventOverflow?: {
+                y: number;
+                x: number;
+            } | undefined;
+            popperOffsets?: {
+                y: number;
+                x: number;
+            } | undefined;
+        };
+        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>>;
+} | null>];

package/dist/runtime/composables/usePopper.mjs

@@ -0,0 +1,78 @@
+import { ref, onMounted, watchEffect } from "vue";
+import { popperGenerator, defaultModifiers } from "@popperjs/core/lib/popper-lite";
+import { omitBy, isUndefined } from "lodash-es";
+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 { unrefElement } from "@vueuse/core";
+export const createPopper = popperGenerator({
+  defaultModifiers: [...defaultModifiers, offset, flip, preventOverflow, computeStyles, eventListeners]
+});
+export function usePopper({
+  locked = false,
+  overflowPadding = 8,
+  offsetDistance = 8,
+  offsetSkid = 0,
+  gpuAcceleration = true,
+  adaptive = true,
+  scroll = true,
+  resize = true,
+  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;
+      }
+      instance.value = createPopper(referenceEl, popperEl, omitBy({
+        placement,
+        strategy,
+        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
+          }
+        }]
+      }, isUndefined));
+      onInvalidate(instance.value.destroy);
+    });
+  });
+  return [reference, popper, instance];
+}

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

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

package/dist/runtime/composables/useShortcuts.mjs

@@ -0,0 +1,24 @@
+import { createSharedComposable, useActiveElement } from "@vueuse/core";
+import { ref, computed, onMounted } from "vue";
+export const _useShortcuts = () => {
+  const macOS = computed(() => process.client && navigator && navigator.userAgent && navigator.userAgent.match(/Macintosh;/));
+  const metaSymbol = ref(" ");
+  const activeElement = useActiveElement();
+  const usingInput = computed(() => {
+    const usingInput2 = !!(activeElement.value?.tagName === "INPUT" || activeElement.value?.tagName === "TEXTAREA" || activeElement.value?.contentEditable === "true");
+    if (usingInput2) {
+      return activeElement.value?.name || true;
+    }
+    return false;
+  });
+  onMounted(() => {
+    metaSymbol.value = macOS.value ? "\u2318" : "Ctrl";
+  });
+  return {
+    macOS,
+    metaSymbol,
+    activeElement,
+    usingInput
+  };
+};
+export const useShortcuts = createSharedComposable(_useShortcuts);

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

@@ -0,0 +1,8 @@
+import type { UseTimestampOptions } from '@vueuse/core';
+export declare function useTimer(cb: (...args: unknown[]) => any, interval: number, options?: UseTimestampOptions<true>): {
+    start: () => void;
+    stop: () => void;
+    pause: () => void;
+    resume: () => void;
+    remaining: import("vue-demi").ComputedRef<number>;
+};