ep-craft 0.1.19 → 0.1.21

package/dist/components/tooltip/src/tooltip.vue.js

@@ -0,0 +1,236 @@
+import { defineComponent as x, ref as l, toRef as s, computed as b, provide as M, unref as p, readonly as N, watch as $, onDeactivated as H, onBeforeUnmount as L, openBlock as f, createBlock as w, withCtx as y, createVNode as h, renderSlot as B, createCommentVNode as T, createElementBlock as C, toDisplayString as z, mergeDefaults as K } from "vue";
+import { ElPopper as U } from "../../popper/index.js";
+import { isBoolean as k } from "../../../utils/types.js";
+import { useNamespace as j } from "../../../hooks/use-namespace/index.js";
+import { useId as V } from "../../../hooks/use-id/index.js";
+import "../../../hooks/use-size/index.js";
+import { usePopperContainer as J } from "../../../hooks/use-popper-container/index.js";
+import "../../../hooks/use-z-index/index.js";
+import { useDelayedToggle as Y } from "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { TOOLTIP_INJECTION_KEY as q } from "./constants.js";
+import { tooltipEmits as G, useTooltipModelToggle as Q } from "./tooltip.js";
+import W from "./trigger.vue.js";
+import X from "./content.vue.js";
+import { useTooltipContentPropsDefaults as Z } from "./content.js";
+import { useTooltipTriggerPropsDefaults as _ } from "./trigger.js";
+import ee from "../../popper/src/arrow2.vue.js";
+import { popperArrowPropsDefaults as te } from "../../popper/src/arrow.js";
+const oe = ["innerHTML"], ne = { key: 1 }, ke = /* @__PURE__ */ x({
+  name: "ElTooltip",
+  __name: "tooltip",
+  props: /* @__PURE__ */ K({
+    showArrow: { type: Boolean },
+    "onUpdate:visible": { type: Function },
+    role: {},
+    appendTo: {},
+    content: {},
+    rawContent: { type: Boolean },
+    persistent: { type: Boolean },
+    visible: { type: [Boolean, null] },
+    transition: {},
+    teleported: { type: Boolean },
+    disabled: { type: Boolean },
+    ariaLabel: {},
+    showAfter: {},
+    hideAfter: {},
+    autoClose: {},
+    id: {},
+    style: { type: [Boolean, null, String, Object, Array] },
+    className: {},
+    effect: {},
+    enterable: { type: Boolean },
+    pure: { type: Boolean },
+    focusOnShow: { type: Boolean },
+    trapping: { type: Boolean },
+    popperClass: {},
+    popperStyle: { type: [Boolean, null, String, Object, Array] },
+    referenceEl: {},
+    triggerTargetEl: {},
+    stopPopperMouseEvent: { type: Boolean },
+    virtualTriggering: { type: Boolean },
+    zIndex: {},
+    loop: { type: Boolean },
+    boundariesPadding: {},
+    fallbackPlacements: {},
+    gpuAcceleration: { type: Boolean },
+    offset: {},
+    placement: {},
+    popperOptions: {},
+    strategy: {},
+    arrowOffset: {},
+    trigger: {},
+    triggerKeys: {},
+    focusOnTarget: { type: Boolean },
+    virtualRef: {},
+    onMouseenter: { type: Function },
+    onMouseleave: { type: Function },
+    onClick: { type: Function },
+    onKeydown: { type: Function },
+    onFocus: { type: Function },
+    onBlur: { type: Function },
+    onContextmenu: { type: Function },
+    open: { type: Boolean }
+  }, {
+    role: "tooltip",
+    ...Z,
+    ..._,
+    ...te,
+    showArrow: !0
+  }),
+  emits: G,
+  setup(e, { expose: A, emit: O }) {
+    const o = e, i = O;
+    J();
+    const P = j("tooltip"), E = V(), c = l(), u = l(), v = () => {
+      var a;
+      const t = p(c);
+      t && ((a = t.popperInstanceRef) == null || a.update());
+    }, n = l(!1), r = l(), { show: F, hide: g, hasUpdateHandler: I } = Q({
+      indicator: n,
+      toggleReason: r
+    }), { onOpen: d, onClose: m } = Y({
+      showAfter: s(o, "showAfter"),
+      hideAfter: s(o, "hideAfter"),
+      autoClose: s(o, "autoClose"),
+      open: F,
+      close: g
+    }), R = b(
+      () => k(o.visible) && !I.value
+    ), S = b(() => [P.b(), o.popperClass]);
+    M(q, {
+      controlled: R,
+      id: E,
+      open: N(n),
+      trigger: s(o, "trigger"),
+      onOpen: d,
+      onClose: m,
+      onToggle: (t) => {
+        p(n) ? m(t) : d(t);
+      },
+      onShow: () => {
+        i("show", r.value);
+      },
+      onHide: () => {
+        i("hide", r.value);
+      },
+      onBeforeShow: () => {
+        i("before-show", r.value);
+      },
+      onBeforeHide: () => {
+        i("before-hide", r.value);
+      },
+      updatePopper: v
+    }), $(
+      () => o.disabled,
+      (t) => {
+        t && n.value && (n.value = !1), !t && k(o.visible) && (n.value = o.visible);
+      }
+    );
+    const D = (t) => {
+      var a;
+      return (a = u.value) == null ? void 0 : a.isFocusInsideContent(t);
+    };
+    return H(() => n.value && g()), L(() => {
+      r.value = void 0;
+    }), A({
+      /**
+       * @description el-popper component instance
+       */
+      popperRef: c,
+      /**
+       * @description el-tooltip-content component instance
+       */
+      contentRef: u,
+      /**
+       * @description validate current focus event is trigger inside el-tooltip-content
+       */
+      isFocusInsideContent: D,
+      /**
+       * @description update el-popper component instance
+       */
+      updatePopper: v,
+      /**
+       * @description expose onOpen function to mange el-tooltip open state
+       */
+      onOpen: d,
+      /**
+       * @description expose onClose function to manage el-tooltip close state
+       */
+      onClose: m,
+      /**
+       * @description expose hide function
+       */
+      hide: g
+    }), (t, a) => (f(), w(p(U), {
+      ref_key: "popperRef",
+      ref: c,
+      role: e.role
+    }, {
+      default: y(() => [
+        h(W, {
+          disabled: e.disabled,
+          trigger: e.trigger,
+          "trigger-keys": e.triggerKeys,
+          "virtual-ref": e.virtualRef,
+          "virtual-triggering": e.virtualTriggering,
+          "focus-on-target": e.focusOnTarget
+        }, {
+          default: y(() => [
+            t.$slots.default ? B(t.$slots, "default", {}, void 0, void 0, 0) : T("", !0)
+          ]),
+          _: 3
+        }, 8, ["disabled", "trigger", "trigger-keys", "virtual-ref", "virtual-triggering", "focus-on-target"]),
+        h(X, {
+          ref_key: "contentRef",
+          ref: u,
+          "aria-label": e.ariaLabel,
+          "boundaries-padding": e.boundariesPadding,
+          content: e.content,
+          disabled: e.disabled,
+          effect: e.effect,
+          enterable: e.enterable,
+          "fallback-placements": e.fallbackPlacements,
+          "hide-after": e.hideAfter,
+          "gpu-acceleration": e.gpuAcceleration,
+          offset: e.offset,
+          persistent: e.persistent,
+          "popper-class": S.value,
+          "popper-style": e.popperStyle,
+          placement: e.placement,
+          "popper-options": e.popperOptions,
+          "arrow-offset": e.arrowOffset,
+          pure: e.pure,
+          "raw-content": e.rawContent,
+          "reference-el": e.referenceEl,
+          "trigger-target-el": e.triggerTargetEl,
+          "show-after": e.showAfter,
+          strategy: e.strategy,
+          teleported: e.teleported,
+          transition: e.transition,
+          "virtual-triggering": e.virtualTriggering,
+          "z-index": e.zIndex,
+          "append-to": e.appendTo,
+          loop: e.loop
+        }, {
+          default: y(() => [
+            B(t.$slots, "content", {}, () => [
+              e.rawContent ? (f(), C("span", {
+                key: 0,
+                innerHTML: e.content
+              }, null, 8, oe)) : (f(), C("span", ne, z(e.content), 1))
+            ]),
+            e.showArrow ? (f(), w(p(ee), { key: 0 })) : T("", !0)
+          ]),
+          _: 3
+        }, 8, ["aria-label", "boundaries-padding", "content", "disabled", "effect", "enterable", "fallback-placements", "hide-after", "gpu-acceleration", "offset", "persistent", "popper-class", "popper-style", "placement", "popper-options", "arrow-offset", "pure", "raw-content", "reference-el", "trigger-target-el", "show-after", "strategy", "teleported", "transition", "virtual-triggering", "z-index", "append-to", "loop"])
+      ]),
+      _: 3
+    }, 8, ["role"]));
+  }
+});
+export {
+  ke as default
+};

package/dist/components/tooltip/src/tooltip2.vue.js

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

package/dist/components/tooltip/src/trigger.d.ts

@@ -0,0 +1,94 @@
+import type { PopperTriggerProps } from '@element-plus/components/popper';
+import type { Arrayable } from '@element-plus/utils';
+import type { ExtractPublicPropTypes } from 'vue';
+export type TooltipTriggerType = 'hover' | 'focus' | 'click' | 'contextmenu';
+export interface UseTooltipTriggerProps extends PopperTriggerProps {
+    /**
+     * @description whether Tooltip is disabled
+     */
+    disabled?: boolean;
+    /**
+     * @description How should the tooltip be triggered (to show), not valid in controlled mode
+     */
+    trigger?: Arrayable<TooltipTriggerType>;
+    /**
+     * @description When you click the mouse to focus on the trigger element, you can define a set of keyboard codes to control the display of tooltip through the keyboard, not valid in controlled mode
+     */
+    triggerKeys?: string[];
+    /**
+     * @description when triggering tooltips through hover, whether to focus the trigger element, which improves accessibility
+     */
+    focusOnTarget?: boolean;
+}
+export declare const useTooltipTriggerPropsDefaults: {
+    readonly trigger: "hover";
+    readonly triggerKeys: () => string[];
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `UseTooltipTriggerProps` instead.
+ */
+export declare const useTooltipTriggerProps: {
+    readonly disabled: BooleanConstructor;
+    readonly trigger: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => "click" | "contextmenu" | "focus" | "hover" | TooltipTriggerType[]) | (() => Arrayable<TooltipTriggerType>) | (((new (...args: any[]) => "click" | "contextmenu" | "focus" | "hover" | TooltipTriggerType[]) | (() => Arrayable<TooltipTriggerType>)) | null)[], unknown, unknown, "hover", boolean>;
+    readonly triggerKeys: import("@element-plus/utils").EpPropFinalized<(new (...args: any[]) => string[]) | (() => string[]) | (((new (...args: any[]) => string[]) | (() => string[])) | null)[], unknown, unknown, () => string[], boolean>;
+    readonly focusOnTarget: BooleanConstructor;
+    readonly virtualRef: {
+        readonly type: import("vue").PropType<import("@element-plus/components/popper").Measurable>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly virtualTriggering: BooleanConstructor;
+    readonly onMouseenter: {
+        readonly type: import("vue").PropType<(e: MouseEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onMouseleave: {
+        readonly type: import("vue").PropType<(e: MouseEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onClick: {
+        readonly type: import("vue").PropType<(e: PointerEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onKeydown: {
+        readonly type: import("vue").PropType<(e: KeyboardEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onFocus: {
+        readonly type: import("vue").PropType<(e: FocusEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onBlur: {
+        readonly type: import("vue").PropType<(e: FocusEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly onContextmenu: {
+        readonly type: import("vue").PropType<(e: PointerEvent) => void>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    readonly id: StringConstructor;
+    readonly open: BooleanConstructor;
+};
+/**
+ * @deprecated Removed after 3.0.0, Use `UseTooltipTriggerProps` instead.
+ */
+export type ElTooltipTriggerProps = UseTooltipTriggerProps;
+/**
+ * @deprecated Removed after 3.0.0, Use `UseTooltipTriggerProps` instead.
+ */
+export type ElTooltipTriggerPropsPublic = ExtractPublicPropTypes<typeof useTooltipTriggerProps>;

package/dist/components/tooltip/src/trigger.js

@@ -0,0 +1,41 @@
+import { EVENT_CODE as r } from "../../../constants/aria.js";
+import { buildProps as o, definePropType as e } from "../../../utils/vue/props/runtime.js";
+import "vue";
+import "../../popper/index.js";
+import { popperTriggerProps as t } from "../../popper/src/trigger.js";
+const n = {
+  trigger: "hover",
+  triggerKeys: () => [
+    r.enter,
+    r.numpadEnter,
+    r.space
+  ]
+}, m = o({
+  ...t,
+  /**
+   * @description whether Tooltip is disabled
+   */
+  disabled: Boolean,
+  /**
+   * @description How should the tooltip be triggered (to show), not valid in controlled mode
+   */
+  trigger: {
+    type: e([String, Array]),
+    default: "hover"
+  },
+  /**
+   * @description When you click the mouse to focus on the trigger element, you can define a set of keyboard codes to control the display of tooltip through the keyboard, not valid in controlled mode
+   */
+  triggerKeys: {
+    type: e(Array),
+    default: () => [r.enter, r.numpadEnter, r.space]
+  },
+  /**
+   * @description when triggering tooltips through hover, whether to focus the trigger element, which improves accessibility
+   */
+  focusOnTarget: Boolean
+});
+export {
+  m as useTooltipTriggerProps,
+  n as useTooltipTriggerPropsDefaults
+};

package/dist/components/tooltip/src/trigger.vue.d.ts

@@ -0,0 +1,26 @@
+import type { UseTooltipTriggerProps } from './trigger';
+import type { OnlyChildExpose } from '@element-plus/components/slot';
+declare var __VLS_16: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_16) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<UseTooltipTriggerProps, {
+    /**
+     * @description trigger element
+     */
+    triggerRef: import("vue").Ref<{
+        forwardRef: HTMLElement;
+    } | null, OnlyChildExpose | {
+        forwardRef: HTMLElement;
+    } | null>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<UseTooltipTriggerProps> & Readonly<{}>, {
+    trigger: import("@element-plus/utils").Arrayable<import("./trigger").TooltipTriggerType>;
+    triggerKeys: string[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/tooltip/src/trigger.vue.js

@@ -0,0 +1,104 @@
+import { defineComponent as K, inject as O, ref as h, toRef as w, openBlock as E, createBlock as _, unref as e, normalizeClass as D, withCtx as b, renderSlot as R, mergeDefaults as I, nextTick as N } from "vue";
+import "../../popper/index.js";
+import { focusElement as P } from "../../../utils/dom/aria.js";
+import { composeEventHandlers as n, getEventCode as S } from "../../../utils/dom/event.js";
+import { useNamespace as $ } from "../../../hooks/use-namespace/index.js";
+import "../../../hooks/use-size/index.js";
+import "../../../hooks/use-z-index/index.js";
+import "../../../hooks/use-delayed-toggle/index.js";
+import "../../../hooks/use-aria/index.js";
+import "../../../hooks/use-model-toggle/index.js";
+import "../../../hooks/use-empty-values/index.js";
+import { TOOLTIP_INJECTION_KEY as j } from "./constants.js";
+import { whenTrigger as i } from "./utils.js";
+import { useTooltipTriggerPropsDefaults as z } from "./trigger.js";
+import H from "../../popper/src/trigger2.vue.js";
+const no = /* @__PURE__ */ K({
+  name: "ElTooltipTrigger",
+  __name: "trigger",
+  props: /* @__PURE__ */ I({
+    disabled: { type: Boolean },
+    trigger: {},
+    triggerKeys: {},
+    focusOnTarget: { type: Boolean },
+    virtualRef: {},
+    virtualTriggering: { type: Boolean },
+    onMouseenter: { type: Function },
+    onMouseleave: { type: Function },
+    onClick: { type: Function },
+    onKeydown: { type: Function },
+    onFocus: { type: Function },
+    onBlur: { type: Function },
+    onContextmenu: { type: Function },
+    id: {},
+    open: { type: Boolean }
+  }, z),
+  setup(l, { expose: g }) {
+    const s = l, m = $("tooltip"), { controlled: f, id: d, open: v, onOpen: c, onClose: p, onToggle: u } = O(
+      j,
+      void 0
+    ), y = h(null), t = () => {
+      if (e(f) || s.disabled)
+        return !0;
+    }, r = w(s, "trigger"), C = n(
+      t,
+      i(r, "hover", (o) => {
+        c(o), s.focusOnTarget && o.target && N(() => {
+          P(o.target, { preventScroll: !0 });
+        });
+      })
+    ), T = n(
+      t,
+      i(r, "hover", p)
+    ), F = n(
+      t,
+      i(r, "click", (o) => {
+        o.button === 0 && u(o);
+      })
+    ), B = n(
+      t,
+      i(r, "focus", c)
+    ), x = n(
+      t,
+      i(r, "focus", p)
+    ), M = n(
+      t,
+      i(r, "contextmenu", (o) => {
+        o.preventDefault(), u(o);
+      })
+    ), k = n(
+      t,
+      (o) => {
+        const a = S(o);
+        s.triggerKeys.includes(a) && (o.preventDefault(), u(o));
+      }
+    );
+    return g({
+      /**
+       * @description trigger element
+       */
+      triggerRef: y
+    }), (o, a) => (E(), _(e(H), {
+      id: e(d),
+      "virtual-ref": l.virtualRef,
+      open: e(v),
+      "virtual-triggering": l.virtualTriggering,
+      class: D(e(m).e("trigger")),
+      onBlur: e(x),
+      onClick: e(F),
+      onContextmenu: e(M),
+      onFocus: e(B),
+      onMouseenter: e(C),
+      onMouseleave: e(T),
+      onKeydown: e(k)
+    }, {
+      default: b(() => [
+        R(o.$slots, "default")
+      ]),
+      _: 3
+    }, 8, ["id", "virtual-ref", "open", "virtual-triggering", "class", "onBlur", "onClick", "onContextmenu", "onFocus", "onMouseenter", "onMouseleave", "onKeydown"]));
+  }
+});
+export {
+  no as default
+};

package/dist/components/tooltip/src/trigger2.vue.js

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

package/dist/components/tooltip/src/utils.d.ts

@@ -0,0 +1,5 @@
+import type { Arrayable } from '@element-plus/utils';
+import type { Ref } from 'vue';
+import type { TooltipTriggerType } from './trigger';
+export declare const isTriggerType: (trigger: Arrayable<TooltipTriggerType>, type: TooltipTriggerType) => boolean;
+export declare const whenTrigger: (trigger: Ref<Arrayable<TooltipTriggerType>>, type: TooltipTriggerType, handler: (e: Event) => void) => (e: Event) => void;

package/dist/components/tooltip/src/utils.js

@@ -0,0 +1,9 @@
+import { unref as i } from "vue";
+import { isArray as s } from "../../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+const t = (r, n) => s(r) ? r.includes(n) : r === n, m = (r, n, e) => (o) => {
+  t(i(r), n) && e(o);
+};
+export {
+  t as isTriggerType,
+  m as whenTrigger
+};

package/dist/constants/aria.d.ts

@@ -0,0 +1,17 @@
+export declare const EVENT_CODE: {
+    tab: string;
+    enter: string;
+    space: string;
+    left: string;
+    up: string;
+    right: string;
+    down: string;
+    esc: string;
+    delete: string;
+    backspace: string;
+    numpadEnter: string;
+    pageUp: string;
+    pageDown: string;
+    home: string;
+    end: string;
+};

package/dist/constants/aria.js

@@ -0,0 +1,24 @@
+const e = {
+  tab: "Tab",
+  enter: "Enter",
+  space: "Space",
+  left: "ArrowLeft",
+  // 37
+  up: "ArrowUp",
+  // 38
+  right: "ArrowRight",
+  // 39
+  down: "ArrowDown",
+  // 40
+  esc: "Escape",
+  delete: "Delete",
+  backspace: "Backspace",
+  numpadEnter: "NumpadEnter",
+  pageUp: "PageUp",
+  pageDown: "PageDown",
+  home: "Home",
+  end: "End"
+};
+export {
+  e as EVENT_CODE
+};

package/dist/constants/column-alignment.d.ts

@@ -0,0 +1,2 @@
+export declare const columnAlignment: readonly ["left", "center", "right"];
+export type ColumnAlignment = (typeof columnAlignment)[number];

package/dist/constants/date.d.ts

@@ -0,0 +1,3 @@
+export declare const datePickTypes: readonly ["year", "years", "month", "months", "date", "dates", "week", "datetime", "datetimerange", "daterange", "monthrange", "yearrange"];
+export declare const WEEK_DAYS: readonly ["sun", "mon", "tue", "wed", "thu", "fri", "sat"];
+export type DatePickType = (typeof datePickTypes)[number];

package/dist/constants/event.d.ts

@@ -0,0 +1,3 @@
+export declare const UPDATE_MODEL_EVENT = "update:modelValue";
+export declare const CHANGE_EVENT = "change";
+export declare const INPUT_EVENT = "input";

package/dist/constants/form.d.ts

@@ -0,0 +1,2 @@
+export declare const MINIMUM_INPUT_WIDTH = 11;
+export declare const BORDER_HORIZONTAL_WIDTH = 2;

package/dist/constants/index.d.ts

@@ -0,0 +1,7 @@
+export * from './aria';
+export * from './column-alignment';
+export * from './date';
+export * from './event';
+export * from './form';
+export * from './key';
+export * from './size';

package/dist/constants/key.d.ts

@@ -0,0 +1 @@
+export declare const INSTALLED_KEY: unique symbol;

package/dist/constants/size.d.ts

@@ -0,0 +1,7 @@
+export declare const componentSizes: readonly ["", "default", "small", "large"];
+export type ComponentSize = (typeof componentSizes)[number];
+export declare const componentSizeMap: {
+    readonly large: 40;
+    readonly default: 32;
+    readonly small: 24;
+};

package/dist/constants/size.js

@@ -0,0 +1,4 @@
+const e = ["", "default", "small", "large"];
+export {
+  e as componentSizes
+};

package/dist/directives/click-outside/index.d.ts

@@ -0,0 +1,3 @@
+import type { ObjectDirective } from 'vue';
+declare const ClickOutside: ObjectDirective<HTMLElement, any>;
+export default ClickOutside;

package/dist/directives/index.d.ts

@@ -0,0 +1,5 @@
+import ClickOutside from "./click-outside/index";
+import { vRepeatClick } from "./repeat-click/index";
+import TrapFocus from "./trap-focus/index";
+import Mousewheel from "./mousewheel/index";
+export { ClickOutside, Mousewheel, TrapFocus, vRepeatClick };

package/dist/directives/mousewheel/index.d.ts

@@ -0,0 +1,11 @@
+import type { ObjectDirective } from 'vue';
+import type { NormalizedWheelEvent } from 'normalize-wheel-es';
+export declare const SCOPE = "_Mousewheel";
+export interface WheelElement extends HTMLElement {
+    [SCOPE]: null | {
+        wheelHandler?: (event: WheelEvent) => void;
+    };
+}
+export type MousewheelCallback = (e: WheelEvent, normalized: NormalizedWheelEvent) => void;
+declare const Mousewheel: ObjectDirective<WheelElement, MousewheelCallback>;
+export default Mousewheel;

package/dist/directives/repeat-click/index.d.ts

@@ -0,0 +1,17 @@
+import type { ObjectDirective } from 'vue';
+export declare const REPEAT_INTERVAL = 100;
+export declare const REPEAT_DELAY = 600;
+declare const SCOPE = "_RepeatClick";
+interface RepeatClickEl extends HTMLElement {
+    [SCOPE]: null | {
+        start?: (evt: MouseEvent) => void;
+        clear?: () => void;
+    };
+}
+export interface RepeatClickOptions {
+    interval?: number;
+    delay?: number;
+    handler: (...args: unknown[]) => unknown;
+}
+export declare const vRepeatClick: ObjectDirective<RepeatClickEl, RepeatClickOptions | RepeatClickOptions['handler']>;
+export {};