测试

frontend/node_modules/element-plus/es/hooks/use-model-toggle/index.d.ts

@@ -0,0 +1,46 @@
+import type { ExtractPropType } from 'element-plus/es/utils';
+import type { ExtractPropTypes, Ref, __ExtractPublicPropTypes } from 'vue';
+declare const _prop: import("element-plus/es/utils").EpPropFinalized<(new (...args: any[]) => boolean) | (() => boolean | null) | ((new (...args: any[]) => boolean) | (() => boolean | null))[], never, never, null, false>;
+declare const _event: {
+    readonly type: import("vue").PropType<(val: boolean) => void>;
+    readonly required: false;
+    readonly validator: ((val: unknown) => boolean) | undefined;
+    __epPropKey: true;
+};
+export type UseModelTogglePropsRaw<T extends string> = {
+    [K in T]: typeof _prop;
+} & {
+    [K in `onUpdate:${T}`]: typeof _event;
+};
+export type UseModelTogglePropsGeneric<T extends string> = {
+    [K in T]: ExtractPropType<typeof _prop>;
+} & {
+    [K in `onUpdate:${T}`]: ExtractPropType<typeof _event>;
+};
+export declare const createModelToggleComposable: <T extends string>(name: T) => {
+    useModelToggle: ({ indicator, toggleReason, shouldHideWhenRouteChanges, shouldProceed, onShow, onHide, }: ModelToggleParams) => {
+        hide: (event?: Event) => void;
+        show: (event?: Event) => void;
+        toggle: () => void;
+        hasUpdateHandler: import("vue").ComputedRef<boolean>;
+    };
+    useModelToggleProps: UseModelTogglePropsRaw<T>;
+    useModelToggleEmits: `update:${T}`[];
+};
+declare const useModelToggle: ({ indicator, toggleReason, shouldHideWhenRouteChanges, shouldProceed, onShow, onHide, }: ModelToggleParams) => {
+    hide: (event?: Event) => void;
+    show: (event?: Event) => void;
+    toggle: () => void;
+    hasUpdateHandler: import("vue").ComputedRef<boolean>;
+}, useModelToggleProps: UseModelTogglePropsRaw<"modelValue">, useModelToggleEmits: "update:modelValue"[];
+export { useModelToggle, useModelToggleEmits, useModelToggleProps };
+export type UseModelToggleProps = ExtractPropTypes<typeof useModelToggleProps>;
+export type UseModelTogglePropsPublic = __ExtractPublicPropTypes<typeof useModelToggleProps>;
+export type ModelToggleParams = {
+    indicator: Ref<boolean>;
+    toggleReason?: Ref<Event | undefined>;
+    shouldHideWhenRouteChanges?: Ref<boolean>;
+    shouldProceed?: () => boolean;
+    onShow?: (event?: Event) => void;
+    onHide?: (event?: Event) => void;
+};

frontend/node_modules/element-plus/es/hooks/use-model-toggle/index.mjs

@@ -0,0 +1,132 @@
+import { getCurrentInstance, computed, watch, onMounted } from 'vue';
+import { buildProp, definePropType } from '../../utils/vue/props/runtime.mjs';
+import { isBoolean } from '../../utils/types.mjs';
+import { isFunction } from '@vue/shared';
+import { isClient } from '@vueuse/core';
+
+const _prop = buildProp({
+  type: definePropType(Boolean),
+  default: null
+});
+const _event = buildProp({
+  type: definePropType(Function)
+});
+const createModelToggleComposable = (name) => {
+  const updateEventKey = `update:${name}`;
+  const updateEventKeyRaw = `onUpdate:${name}`;
+  const useModelToggleEmits2 = [updateEventKey];
+  const useModelToggleProps2 = {
+    [name]: _prop,
+    [updateEventKeyRaw]: _event
+  };
+  const useModelToggle2 = ({
+    indicator,
+    toggleReason,
+    shouldHideWhenRouteChanges,
+    shouldProceed,
+    onShow,
+    onHide
+  }) => {
+    const instance = getCurrentInstance();
+    const { emit } = instance;
+    const props = instance.props;
+    const hasUpdateHandler = computed(() => isFunction(props[updateEventKeyRaw]));
+    const isModelBindingAbsent = computed(() => props[name] === null);
+    const doShow = (event) => {
+      if (indicator.value === true) {
+        return;
+      }
+      indicator.value = true;
+      if (toggleReason) {
+        toggleReason.value = event;
+      }
+      if (isFunction(onShow)) {
+        onShow(event);
+      }
+    };
+    const doHide = (event) => {
+      if (indicator.value === false) {
+        return;
+      }
+      indicator.value = false;
+      if (toggleReason) {
+        toggleReason.value = event;
+      }
+      if (isFunction(onHide)) {
+        onHide(event);
+      }
+    };
+    const show = (event) => {
+      if (props.disabled === true || isFunction(shouldProceed) && !shouldProceed())
+        return;
+      const shouldEmit = hasUpdateHandler.value && isClient;
+      if (shouldEmit) {
+        emit(updateEventKey, true);
+      }
+      if (isModelBindingAbsent.value || !shouldEmit) {
+        doShow(event);
+      }
+    };
+    const hide = (event) => {
+      if (props.disabled === true || !isClient)
+        return;
+      const shouldEmit = hasUpdateHandler.value && isClient;
+      if (shouldEmit) {
+        emit(updateEventKey, false);
+      }
+      if (isModelBindingAbsent.value || !shouldEmit) {
+        doHide(event);
+      }
+    };
+    const onChange = (val) => {
+      if (!isBoolean(val))
+        return;
+      if (props.disabled && val) {
+        if (hasUpdateHandler.value) {
+          emit(updateEventKey, false);
+        }
+      } else if (indicator.value !== val) {
+        if (val) {
+          doShow();
+        } else {
+          doHide();
+        }
+      }
+    };
+    const toggle = () => {
+      if (indicator.value) {
+        hide();
+      } else {
+        show();
+      }
+    };
+    watch(() => props[name], onChange);
+    if (shouldHideWhenRouteChanges && instance.appContext.config.globalProperties.$route !== void 0) {
+      watch(() => ({
+        ...instance.proxy.$route
+      }), () => {
+        if (shouldHideWhenRouteChanges.value && indicator.value) {
+          hide();
+        }
+      });
+    }
+    onMounted(() => {
+      onChange(props[name]);
+    });
+    return {
+      hide,
+      show,
+      toggle,
+      hasUpdateHandler
+    };
+  };
+  return {
+    useModelToggle: useModelToggle2,
+    useModelToggleProps: useModelToggleProps2,
+    useModelToggleEmits: useModelToggleEmits2
+  };
+};
+const { useModelToggle, useModelToggleProps, useModelToggleEmits } = createModelToggleComposable("modelValue");
+
+export { createModelToggleComposable, useModelToggle, useModelToggleEmits, useModelToggleProps };
+//# sourceMappingURL=index.mjs.map