测试

frontend/node_modules/element-plus/lib/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?: {
+                left: number;
+                right: number;
+                top: number;
+                bottom: number;
+            } | undefined;
+            escapedOffsets?: {
+                left: number;
+                right: number;
+                top: number;
+                bottom: 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;

frontend/node_modules/element-plus/lib/hooks/use-floating/index.js

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