init

node_modules/element-plus/es/hooks/use-floating/index.d.ts

@@ -0,0 +1,69 @@
+import type { Ref, ToRefs } from 'vue';
+import type { Middleware, Placement, SideObject, Strategy, VirtualElement } from '@floating-ui/dom';
+export declare const useFloatingProps: {};
+export type UseFloatingProps = ToRefs<{
+    middleware: Array<Middleware>;
+    placement: Placement;
+    strategy: Strategy;
+}>;
+export declare const getPositionDataWithUnit: <T extends Record<string, number>>(record: T | undefined, key: keyof T) => string;
+export declare const useFloating: ({ middleware, placement, strategy, }: UseFloatingProps) => {
+    update: () => Promise<void>;
+    referenceRef: Ref<HTMLElement | VirtualElement | undefined>;
+    contentRef: Ref<HTMLElement | undefined>;
+    x: Ref<number | undefined>;
+    y: Ref<number | undefined>;
+    placement: Ref<Placement>;
+    strategy: Ref<Strategy>;
+    middlewareData: Ref<{
+        [x: string]: any;
+        arrow?: {
+            x?: number | undefined;
+            y?: number | undefined;
+            centerOffset: number;
+        } | undefined;
+        autoPlacement?: {
+            index?: number | undefined;
+            overflows: {
+                placement: Placement;
+                overflows: Array<number>;
+            }[];
+        } | undefined;
+        flip?: {
+            index?: number | undefined;
+            overflows: {
+                placement: Placement;
+                overflows: Array<number>;
+            }[];
+        } | undefined;
+        hide?: {
+            referenceHidden?: boolean | undefined;
+            escaped?: boolean | undefined;
+            referenceHiddenOffsets?: {
+                top: number;
+                bottom: number;
+                left: number;
+                right: number;
+            } | undefined;
+            escapedOffsets?: {
+                top: number;
+                bottom: number;
+                left: number;
+                right: number;
+            } | undefined;
+        } | undefined;
+        offset?: {
+            x: number;
+            y: number;
+        } | undefined;
+        shift?: {
+            x: number;
+            y: number;
+        } | undefined;
+    }>;
+};
+export type ArrowMiddlewareProps = {
+    arrowRef: Ref<HTMLElement | null | undefined>;
+    padding?: number | SideObject;
+};
+export declare const arrowMiddleware: ({ arrowRef, padding, }: ArrowMiddlewareProps) => Middleware;

node_modules/element-plus/es/hooks/use-floating/index.mjs

@@ -0,0 +1,91 @@
+import { unref, ref, onMounted, watchEffect, isRef } from 'vue';
+import { isClient, unrefElement } from '@vueuse/core';
+import { isNil } from 'lodash-unified';
+import { arrow, computePosition } from '@floating-ui/dom';
+import { keysOf } from '../../utils/objects.mjs';
+import { buildProps } from '../../utils/vue/props/runtime.mjs';
+
+const useFloatingProps = buildProps({});
+const unrefReference = (elRef) => {
+  if (!isClient)
+    return;
+  if (!elRef)
+    return elRef;
+  const unrefEl = unrefElement(elRef);
+  if (unrefEl)
+    return unrefEl;
+  return isRef(elRef) ? unrefEl : elRef;
+};
+const getPositionDataWithUnit = (record, key) => {
+  const value = record == null ? void 0 : record[key];
+  return isNil(value) ? "" : `${value}px`;
+};
+const useFloating = ({
+  middleware,
+  placement,
+  strategy
+}) => {
+  const referenceRef = ref();
+  const contentRef = ref();
+  const x = ref();
+  const y = ref();
+  const middlewareData = ref({});
+  const states = {
+    x,
+    y,
+    placement,
+    strategy,
+    middlewareData
+  };
+  const update = async () => {
+    if (!isClient)
+      return;
+    const referenceEl = unrefReference(referenceRef);
+    const contentEl = unrefElement(contentRef);
+    if (!referenceEl || !contentEl)
+      return;
+    const data = await computePosition(referenceEl, contentEl, {
+      placement: unref(placement),
+      strategy: unref(strategy),
+      middleware: unref(middleware)
+    });
+    keysOf(states).forEach((key) => {
+      states[key].value = data[key];
+    });
+  };
+  onMounted(() => {
+    watchEffect(() => {
+      update();
+    });
+  });
+  return {
+    ...states,
+    update,
+    referenceRef,
+    contentRef
+  };
+};
+const arrowMiddleware = ({
+  arrowRef,
+  padding
+}) => {
+  return {
+    name: "arrow",
+    options: {
+      element: arrowRef,
+      padding
+    },
+    fn(args) {
+      const arrowEl = unref(arrowRef);
+      if (!arrowEl)
+        return {};
+      return arrow({
+        element: arrowEl,
+        padding
+      }).fn(args);
+    }
+  };
+};
+
+export { arrowMiddleware, getPositionDataWithUnit, useFloating, useFloatingProps };
+//# sourceMappingURL=index.mjs.map