ep-craft 0.1.19 → 0.1.21

package/dist/hooks/use-popper/index.js

@@ -0,0 +1,97 @@
+import { computed as n, unref as e, shallowRef as b, ref as v, watch as f, onBeforeUnmount as w } from "vue";
+import { createPopper as S } from "../../node_modules/.pnpm/@sxzz_popperjs-es@2.11.8/node_modules/@sxzz/popperjs-es/dist/index.js";
+import d from "../../node_modules/.pnpm/lodash-es@4.18.1/node_modules/lodash-es/fromPairs.js";
+const P = (r, i, p = {}) => {
+  const u = {
+    name: "updateState",
+    enabled: !0,
+    phase: "write",
+    fn: ({ state: t }) => {
+      const a = U(t);
+      Object.assign(c.value, a);
+    },
+    requires: ["computeStyles"]
+  }, s = n(() => {
+    const { onFirstUpdate: t, placement: a, strategy: m, modifiers: y } = e(p);
+    return {
+      onFirstUpdate: t,
+      placement: a || "bottom",
+      strategy: m || "absolute",
+      modifiers: [
+        ...y || [],
+        u,
+        { name: "applyStyles", enabled: !1 }
+      ]
+    };
+  }), o = b(), c = v({
+    styles: {
+      popper: {
+        position: e(s).strategy,
+        left: "0",
+        top: "0"
+      },
+      arrow: {
+        position: "absolute"
+      }
+    },
+    attributes: {}
+  }), l = () => {
+    o.value && (o.value.destroy(), o.value = void 0);
+  };
+  return f(
+    s,
+    (t) => {
+      const a = e(o);
+      a && a.setOptions(t);
+    },
+    {
+      deep: !0
+    }
+  ), f(
+    [r, i],
+    ([t, a]) => {
+      l(), !(!t || !a) && (o.value = S(
+        t,
+        a,
+        e(s)
+      ));
+    }
+  ), w(() => {
+    l();
+  }), {
+    state: n(() => {
+      var t;
+      return { ...((t = e(o)) == null ? void 0 : t.state) || {} };
+    }),
+    styles: n(() => e(c).styles),
+    attributes: n(() => e(c).attributes),
+    update: () => {
+      var t;
+      return (t = e(o)) == null ? void 0 : t.update();
+    },
+    forceUpdate: () => {
+      var t;
+      return (t = e(o)) == null ? void 0 : t.forceUpdate();
+    },
+    // Preventing end users from modifying the instance.
+    instanceRef: n(() => e(o))
+  };
+};
+function U(r) {
+  const i = Object.keys(r.elements), p = d(
+    i.map(
+      (s) => [s, r.styles[s] || {}]
+    )
+  ), u = d(
+    i.map(
+      (s) => [s, r.attributes[s]]
+    )
+  );
+  return {
+    styles: p,
+    attributes: u
+  };
+}
+export {
+  P as usePopper
+};

package/dist/hooks/use-popper-container/index.d.ts

@@ -0,0 +1,8 @@
+export declare const usePopperContainerId: () => {
+    id: import("vue").ComputedRef<string>;
+    selector: import("vue").ComputedRef<string>;
+};
+export declare const usePopperContainer: () => {
+    id: import("vue").ComputedRef<string>;
+    selector: import("vue").ComputedRef<string>;
+};

package/dist/hooks/use-popper-container/index.js

@@ -0,0 +1,26 @@
+import { onBeforeMount as c, computed as n } from "vue";
+import { useGetDerivedNamespace as i } from "../use-namespace/index.js";
+import { useIdInjection as s } from "../use-id/index.js";
+import { isClient as p } from "../../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+const u = () => {
+  const o = i(), e = s(), t = n(() => `${o.value}-popper-container-${e.prefix}`), r = n(() => `#${t.value}`);
+  return {
+    id: t,
+    selector: r
+  };
+}, a = (o) => {
+  const e = document.createElement("div");
+  return e.id = o, document.body.appendChild(e), e;
+}, v = () => {
+  const { id: o, selector: e } = u();
+  return c(() => {
+    p && (process.env.NODE_ENV === "test" || !document.body.querySelector(e.value)) && a(o.value);
+  }), {
+    id: o,
+    selector: e
+  };
+};
+export {
+  v as usePopperContainer,
+  u as usePopperContainerId
+};

package/dist/hooks/use-prop/index.d.ts

@@ -0,0 +1,2 @@
+import type { ComputedRef } from 'vue';
+export declare const useProp: <T>(name: string) => ComputedRef<T | undefined>;

package/dist/hooks/use-size/index.d.ts

@@ -0,0 +1,21 @@
+import type { InjectionKey, Ref } from 'vue';
+import type { ComponentSize } from '@element-plus/constants';
+export declare const useSizeProp: {
+    readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+};
+export declare const useSizeProps: {
+    size: {
+        readonly type: import("vue").PropType<import("@element-plus/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", never>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+};
+export interface SizeContext {
+    size: Ref<ComponentSize>;
+}
+export declare const SIZE_INJECTION_KEY: InjectionKey<SizeContext>;
+export declare const useGlobalSize: () => import("vue").ComputedRef<"" | "default" | "small" | "large">;

package/dist/hooks/use-size/index.js

@@ -0,0 +1,8 @@
+import "vue";
+import { componentSizes as r } from "../../constants/size.js";
+import { buildProp as o } from "../../utils/vue/props/runtime.js";
+o({
+  type: String,
+  values: r,
+  required: !1
+});

package/dist/hooks/use-timeout/index.d.ts

@@ -0,0 +1,4 @@
+export declare function useTimeout(): {
+    registerTimeout: (fn: (...args: any[]) => any, delay: number) => void;
+    cancelTimeout: () => void;
+};

package/dist/hooks/use-timeout/index.js

@@ -0,0 +1,16 @@
+import { tryOnScopeDispose as u } from "../../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+function s() {
+  let e;
+  const t = (i, r) => {
+    o(), e = globalThis.setTimeout(i, r);
+  }, o = () => {
+    e !== void 0 && (globalThis.clearTimeout(e), e = void 0);
+  };
+  return u(() => o()), {
+    registerTimeout: t,
+    cancelTimeout: o
+  };
+}
+export {
+  s as useTimeout
+};

package/dist/hooks/use-z-index/index.d.ts

@@ -0,0 +1,13 @@
+import type { InjectionKey, Ref } from 'vue';
+export interface ElZIndexInjectionContext {
+    current: number;
+}
+export declare const defaultInitialZIndex = 2000;
+export declare const ZINDEX_INJECTION_KEY: InjectionKey<ElZIndexInjectionContext>;
+export declare const zIndexContextKey: InjectionKey<Ref<number | undefined>>;
+export declare const useZIndex: (zIndexOverrides?: Ref<number>) => {
+    initialZIndex: import("vue").ComputedRef<number>;
+    currentZIndex: import("vue").ComputedRef<number>;
+    nextZIndex: () => number;
+};
+export type UseZIndexReturn = ReturnType<typeof useZIndex>;

package/dist/hooks/use-z-index/index.js

@@ -0,0 +1,27 @@
+import { ref as a, getCurrentInstance as i, inject as e, computed as c, unref as m } from "vue";
+import { isNumber as l } from "../../utils/types.js";
+import { debugWarn as p } from "../../utils/error.js";
+import { isClient as v } from "../../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+const s = {
+  current: 0
+}, d = a(0), Z = 2e3, u = Symbol("elZIndexContextKey"), f = Symbol("zIndexContextKey"), E = (y) => {
+  const n = i() ? e(u, s) : s, I = i() ? e(f, void 0) : void 0, t = c(() => {
+    const o = m(I);
+    return l(o) ? o : Z;
+  }), r = c(() => t.value + d.value), x = () => (n.current++, d.value = n.current, r.value);
+  return !v && !e(u) && p(
+    "ZIndexInjection",
+    `Looks like you are using server rendering, you must provide a z-index provider to ensure the hydration process to be succeed
+usage: app.provide(ZINDEX_INJECTION_KEY, { current: 0 })`
+  ), {
+    initialZIndex: t,
+    currentZIndex: r,
+    nextZIndex: x
+  };
+};
+export {
+  u as ZINDEX_INJECTION_KEY,
+  Z as defaultInitialZIndex,
+  E as useZIndex,
+  f as zIndexContextKey
+};

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/anchor/src/anchor.vue_vue_type_script_setup_true_lang.js

@@ -1,7 +1,7 @@
 import { CHANGE_EVENT as K } from "../../../constants/event.js";
 import { getOffsetTopDistance as B } from "../../../utils/dom/position.js";
-import { isWindow as P, isUndefined as W } from "../../../utils/types.js";
-import { getScrollElement as H, animateScrollTo as q, getScrollTop as L } from "../../../utils/dom/scroll.js";
+import { isUndefined as P, isWindow as W } from "../../../utils/types.js";
+import { getScrollTop as H, getScrollElement as L, animateScrollTo as q } from "../../../utils/dom/scroll.js";
 import { getElement as m } from "../../../utils/dom/element.js";
 import { throttleByRaf as F } from "../../../utils/throttleByRaf.js";
 import { useNamespace as J } from "../../../hooks/use-namespace/index.js";
@@ -38,7 +38,7 @@ var Te = /* @__PURE__ */ ee({
         g();
       }
       k = e, h = !0;
-      const o = H(t, l.value), n = B(t, o), s = o.scrollHeight - o.clientHeight, I = Math.min(n - r.offset, s);
+      const o = L(t, l.value), n = B(t, o), s = o.scrollHeight - o.clientHeight, I = Math.min(n - r.offset, s);
       g = q(l.value, S, I, r.duration, () => {
         setTimeout(() => {
           h = !1, k = "";
@@ -49,16 +49,16 @@ var Te = /* @__PURE__ */ ee({
     }, D = (e, t) => {
       R("click", e, t), y(t);
     }, w = F(() => {
-      l.value && (S = L(l.value));
+      l.value && (S = H(l.value));
       const e = G();
-      h || W(e) || _(e);
+      h || P(e) || _(e);
     }), G = () => {
       if (!l.value) return;
-      const e = L(l.value), t = [];
+      const e = H(l.value), t = [];
       for (const o of Object.keys(f)) {
         const n = m(o);
         if (!n) continue;
-        const s = B(n, H(n, l.value));
+        const s = B(n, L(n, l.value));
         t.push({
           top: s - r.offset - r.bound,
           href: o
@@ -72,7 +72,7 @@ var Te = /* @__PURE__ */ ee({
       }
     }, x = () => {
       const e = m(r.container);
-      !e || P(e) ? l.value = window : l.value = e;
+      !e || W(e) ? l.value = window : l.value = e;
     };
     Z(l, "scroll", w);
     const A = () => {

package/dist/node_modules/.pnpm/element-plus@2.14.3_vue@3.5.40_typescript@5.9.3_/node_modules/element-plus/es/components/button/index.js

@@ -1,7 +1,7 @@
-import { withInstall as o, withNoopInstall as u } from "../../utils/vue/install.js";
+import { withNoopInstall as o, withInstall as u } from "../../utils/vue/install.js";
 import r from "./src/button2.js";
 import t from "./src/button-group2.js";
-const a = o(r, { ButtonGroup: t }), f = u(t);
+const a = u(r, { ButtonGroup: t }), f = o(t);
 export {
   a as ElButton,
   f as ElButtonGroup,

package/dist/resolver.js

@@ -1,23 +1,24 @@
-function o(s = {}) {
-  const { importStyle: r = !0 } = s;
+import { isVendored as i } from "./vendored-components.js";
+function c(s = {}) {
+  const { importStyle: t = !0 } = s;
   return {
     type: "component",
-    resolve: (t) => {
-      if (!t.startsWith("Ep")) return;
-      const e = t.slice(2);
-      return e === "Button" || e === "ButtonGroup" || e === "Tag" || e === "CheckTag" || e === "Menu" || e === "MenuItem" || e === "MenuItemGroup" || e === "SubMenu" ? {
-        name: t,
+    resolve: (e) => {
+      if (!e.startsWith("Ep")) return;
+      const r = e.slice(2);
+      return i(r) ? {
+        name: e,
         from: "ep-craft",
-        sideEffects: r ? ["ep-craft/dist/index.css"] : void 0
+        sideEffects: t ? ["ep-craft/dist/index.css"] : void 0
       } : {
-        name: `El${e}`,
+        name: `El${r}`,
         from: "ep-craft",
-        sideEffects: r ? ["ep-craft/dist/index.css"] : void 0
+        sideEffects: t ? ["ep-craft/dist/index.css"] : void 0
       };
     }
   };
 }
 export {
-  o as EpCraftResolver,
-  o as default
+  c as EpCraftResolver,
+  c as default
 };

package/dist/utils/arrays.d.ts

@@ -0,0 +1,6 @@
+export declare const unique: <T>(arr: T[]) => T[];
+export declare const extractFirst: <T>(arr: T | T[]) => T;
+type Many<T> = T | ReadonlyArray<T>;
+/** like `_.castArray`, except falsy value returns empty array. */
+export declare const castArray: <T>(arr: Many<T>) => T[];
+export { castArray as ensureArray } from 'lodash-unified';

package/dist/utils/arrays.js

@@ -0,0 +1,5 @@
+import { isArray as o } from "../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+const i = (t) => !t && t !== 0 ? [] : o(t) ? t : [t];
+export {
+  i as castArray
+};

package/dist/utils/browser.d.ts

@@ -0,0 +1,4 @@
+import { isClient, isIOS } from '@vueuse/core';
+export declare const isFirefox: () => boolean;
+export declare const isAndroid: () => boolean;
+export { isClient, isIOS };

package/dist/utils/browser.js

@@ -0,0 +1,6 @@
+import { isClient as i } from "../node_modules/.pnpm/@vueuse_shared@14.3.0_vue@3.5.40_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+const t = () => i && /android/i.test(window.navigator.userAgent);
+export {
+  t as isAndroid,
+  i as isClient
+};

package/dist/utils/dom/aria.d.ts

@@ -0,0 +1,26 @@
+export declare const isShadowRoot: (e: unknown) => e is ShadowRoot;
+/**
+ * Determine if the testing element is visible on screen no matter if its on the viewport or not
+ */
+export declare const isVisible: (element: HTMLElement) => boolean;
+export declare const obtainAllFocusableElements: (element: HTMLElement) => HTMLElement[];
+/**
+ * @desc Determine if target element is focusable
+ * @param element {HTMLElement}
+ * @returns {Boolean} true if it is focusable
+ */
+export declare const isFocusable: (element: HTMLElement) => boolean;
+/**
+ * Trigger an event
+ * mouseenter, mouseleave, mouseover, keyup, change, click, etc.
+ * @param  {HTMLElement} elm
+ * @param  {String} name
+ * @param  {*} opts
+ */
+export declare const triggerEvent: (elm: HTMLElement, name: string, ...opts: Array<boolean>) => HTMLElement;
+export declare const isLeaf: (el: HTMLElement) => boolean;
+export declare const getSibling: (el: HTMLElement, distance: number, elClass: string) => Element | null;
+export declare const focusElement: (el?: HTMLElement | {
+    focus: () => void;
+} | null, options?: FocusOptions) => void;
+export declare const focusNode: (el: HTMLElement) => void;

package/dist/utils/dom/aria.js

@@ -0,0 +1,26 @@
+const e = (t) => typeof Element > "u" ? !1 : t instanceof Element, a = (t) => {
+  if (t.tabIndex > 0 || t.tabIndex === 0 && t.getAttribute("tabIndex") !== null)
+    return !0;
+  if (t.tabIndex < 0 || t.hasAttribute("disabled") || t.getAttribute("aria-disabled") === "true")
+    return !1;
+  switch (t.nodeName) {
+    case "A":
+      return !!t.href && t.rel !== "ignore";
+    case "INPUT":
+      return !(t.type === "hidden" || t.type === "file");
+    case "BUTTON":
+    case "SELECT":
+    case "TEXTAREA":
+      return !0;
+    default:
+      return !1;
+  }
+}, i = (t, u) => {
+  if (!t || !t.focus) return;
+  let r = !1;
+  e(t) && !a(t) && !t.getAttribute("tabindex") && (t.setAttribute("tabindex", "-1"), r = !0), t.focus(u), e(t) && r && t.removeAttribute("tabindex");
+};
+export {
+  i as focusElement,
+  a as isFocusable
+};

package/dist/utils/dom/element.d.ts

@@ -0,0 +1,3 @@
+type GetElement = <T extends string | HTMLElement | Window | null | undefined>(target: T) => T extends string ? HTMLElement | null : T;
+export declare const getElement: GetElement;
+export {};

package/dist/utils/dom/event.d.ts

@@ -0,0 +1,8 @@
+export declare const composeEventHandlers: <E>(theirsHandler?: (event: E) => boolean | void, oursHandler?: (event: E) => void, { checkForDefaultPrevented }?: {
+    checkForDefaultPrevented?: boolean | undefined;
+}) => (event: E) => void;
+type WhenMouseHandler = (e: PointerEvent) => any;
+export declare const whenMouse: (handler: WhenMouseHandler) => WhenMouseHandler;
+export declare const getEventCode: (event: KeyboardEvent) => string;
+export declare const getEventKey: (event: KeyboardEvent) => string;
+export {};

package/dist/utils/dom/event.js

@@ -0,0 +1,32 @@
+import { EVENT_CODE as n } from "../../constants/aria.js";
+import { isAndroid as r } from "../browser.js";
+const y = (t, e, { checkForDefaultPrevented: c = !0 } = {}) => (o) => {
+  const i = t == null ? void 0 : t(o);
+  if (c === !1 || !i)
+    return e == null ? void 0 : e(o);
+}, E = (t) => {
+  if (t.code && t.code !== "Unidentified") return t.code;
+  const e = f(t);
+  if (e) {
+    if (Object.values(n).includes(e)) return e;
+    switch (e) {
+      case " ":
+        return n.space;
+      default:
+        return "";
+    }
+  }
+  return "";
+}, f = (t) => {
+  let e = t.key && t.key !== "Unidentified" ? t.key : "";
+  if (!e && t.type === "keyup" && r()) {
+    const c = t.target;
+    e = c.value.charAt(c.selectionStart - 1);
+  }
+  return e;
+};
+export {
+  y as composeEventHandlers,
+  E as getEventCode,
+  f as getEventKey
+};

package/dist/utils/dom/index.d.ts

@@ -0,0 +1,7 @@
+import { focusElement, focusNode, getSibling, isFocusable, isLeaf, isShadowRoot, isVisible, obtainAllFocusableElements, triggerEvent } from "./aria";
+import { composeEventHandlers, getEventCode, getEventKey, whenMouse } from "./event";
+import { getClientXY, getOffsetTop, getOffsetTopDistance, isInContainer } from "./position";
+import { addClass, addUnit, classNameToArray, getStyle, hasClass, removeClass, removeStyle, setStyle } from "./style";
+import { animateScrollTo, getScrollBarWidth, getScrollContainer, getScrollElement, getScrollTop, isScroll, scrollIntoView } from "./scroll";
+import { getElement } from "./element";
+export { addClass, addUnit, animateScrollTo, classNameToArray, composeEventHandlers, focusElement, focusNode, getClientXY, getElement, getEventCode, getEventKey, getOffsetTop, getOffsetTopDistance, getScrollBarWidth, getScrollContainer, getScrollElement, getScrollTop, getSibling, getStyle, hasClass, isFocusable, isInContainer, isLeaf, isScroll, isShadowRoot, isVisible, obtainAllFocusableElements, removeClass, removeStyle, scrollIntoView, setStyle, triggerEvent, whenMouse };

package/dist/utils/dom/position.d.ts

@@ -0,0 +1,7 @@
+export declare const isInContainer: (el?: Element, container?: Element | Window) => boolean;
+export declare const getOffsetTop: (el: HTMLElement) => number;
+export declare const getOffsetTopDistance: (el: HTMLElement, containerEl: HTMLElement) => number;
+export declare const getClientXY: (event: MouseEvent | TouchEvent) => {
+    clientX: number;
+    clientY: number;
+};

package/dist/utils/dom/scroll.d.ts

@@ -0,0 +1,11 @@
+export declare const isScroll: (el: HTMLElement, isVertical?: boolean) => boolean;
+export declare const getScrollContainer: (el: HTMLElement, isVertical?: boolean) => Window | HTMLElement | undefined;
+export declare const getScrollBarWidth: (namespace: string) => number;
+/**
+ * Scroll with in the container element, positioning the **selected** element at the top
+ * of the container
+ */
+export declare function scrollIntoView(container: HTMLElement, selected: HTMLElement): void;
+export declare function animateScrollTo(container: HTMLElement | Window, from: number, to: number, duration: number, callback?: unknown): () => void;
+export declare const getScrollElement: (target: HTMLElement, container: HTMLElement | Window) => HTMLElement;
+export declare const getScrollTop: (container: HTMLElement | Window) => number;

package/dist/utils/dom/style.d.ts

@@ -0,0 +1,9 @@
+import type { CSSProperties } from 'vue';
+export declare const classNameToArray: (cls?: string) => string[];
+export declare const hasClass: (el: Element, cls: string) => boolean;
+export declare const addClass: (el: Element, cls: string) => void;
+export declare const removeClass: (el: Element, cls: string) => void;
+export declare const getStyle: (element: HTMLElement, styleName: keyof CSSProperties) => string;
+export declare const setStyle: (element: HTMLElement, styleName: CSSProperties | keyof CSSProperties, value?: string | number) => void;
+export declare const removeStyle: (element: HTMLElement, style: CSSProperties | keyof CSSProperties) => void;
+export declare function addUnit(value?: string | number, defaultUnit?: string): string | undefined;

package/dist/utils/dom/style.js

@@ -0,0 +1,15 @@
+import { isNumber as t, isStringNumber as n } from "../types.js";
+import { isString as m } from "../../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+import { debugWarn as o } from "../error.js";
+const s = "utils/dom/style";
+function d(r, i = "px") {
+  if (!r && r !== 0) return "";
+  if (t(r) || n(r))
+    return `${r}${i}`;
+  if (m(r))
+    return r;
+  o(s, "binding value must be a string or number");
+}
+export {
+  d as addUnit
+};

package/dist/utils/easings.d.ts

@@ -0,0 +1 @@
+export declare function easeInOutCubic(t: number, b: number, c: number, d: number): number;

package/dist/utils/error.d.ts

@@ -0,0 +1,3 @@
+export declare function throwError(scope: string, m: string): never;
+export declare function debugWarn(err: Error): void;
+export declare function debugWarn(scope: string, message: string): void;

package/dist/utils/error.js

@@ -0,0 +1,15 @@
+import { isString as e } from "../node_modules/.pnpm/@vue_shared@3.5.40/node_modules/@vue/shared/dist/shared.esm-bundler.js";
+class t extends Error {
+  constructor(n) {
+    super(n), this.name = "ElementPlusError";
+  }
+}
+function i(r, n) {
+  if (process.env.NODE_ENV !== "production") {
+    const o = e(r) ? new t(`[${r}] ${n}`) : r;
+    console.warn(o);
+  }
+}
+export {
+  i as debugWarn
+};

package/dist/utils/functions.d.ts

@@ -0,0 +1,2 @@
+import { NOOP, toRawType } from '@vue/shared';
+export { NOOP, toRawType };

package/dist/utils/i18n.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @deprecated This function is deprecated and will be removed in future versions.
+ */
+export declare const isKorean: (text: string) => boolean;

package/dist/utils/index.d.ts

@@ -0,0 +1,31 @@
+export * from './arrays';
+export * from './browser';
+export * from './easings';
+export * from './error';
+export * from './functions';
+export * from './i18n';
+export * from './numbers';
+export * from './objects';
+export * from './raf';
+export * from './rand';
+export * from './strings';
+export * from './throttleByRaf';
+export * from './types';
+export * from './typescript';
+export * from './dom/aria';
+export * from './dom/element';
+export * from './dom/event';
+export * from './dom/position';
+export * from './dom/scroll';
+export * from './dom/style';
+export * from './vue/global-node';
+export * from './vue/icon';
+export * from './vue/install';
+export * from './vue/refs';
+export * from './vue/size';
+export * from './vue/typescript';
+export * from './vue/validator';
+export * from './vue/vnode';
+export * from './vue/props/runtime';
+export * from './vue/props/types';
+export * from './vue/props/util';

package/dist/utils/numbers.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Due to browser rendering and calculation precision loss issues,
+ * boundary checks cannot be based solely on value equality;
+ * a certain range of fluctuation is permissible.
+ */
+export declare function isGreaterThan(a: number, b: number, epsilon?: number): boolean;

package/dist/utils/objects.d.ts

@@ -0,0 +1,7 @@
+import type { Arrayable } from '.';
+export declare const keysOf: <T extends object>(arr: T) => Array<keyof T>;
+export declare const entriesOf: <T extends object>(arr: T) => [keyof T, T[keyof T]][];
+export { hasOwn } from '@vue/shared';
+export declare const getProp: <T = any>(obj: Record<string, any>, path: Arrayable<string>, defaultValue?: any) => {
+    value: T;
+};

package/dist/utils/raf.d.ts

@@ -0,0 +1,2 @@
+export declare const rAF: (fn: () => void) => number;
+export declare const cAF: (handle: number) => void;

package/dist/utils/rand.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @deprecated Use `useId` `useIdInjection` instead
+ * Generate random number in range [0, 1000]
+ * Maybe replace with [uuid](https://www.npmjs.com/package/uuid)
+ */
+export declare const generateId: () => number;
+/**
+ * @deprecated
+ * Generating a random int in range (0, max - 1)
+ * @param max {number}
+ */
+export declare const getRandomInt: (max: number) => number;

package/dist/utils/strings.d.ts

@@ -0,0 +1,8 @@
+import { camelize, hyphenate } from '@vue/shared';
+export { camelize, hyphenate };
+export declare const kebabCase: (str: string) => string;
+/**
+ * fork from {@link https://github.com/sindresorhus/escape-string-regexp}
+ */
+export declare const escapeStringRegexp: (string?: string) => string;
+export declare const capitalize: <T extends string>(str: T) => Capitalize<T>;

package/dist/utils/throttleByRaf.d.ts

@@ -0,0 +1,4 @@
+export declare function throttleByRaf(cb: (...args: any[]) => void): {
+    (...args: any[]): void;
+    cancel(): void;
+};