init

node_modules/element-plus/lib/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;
+};

node_modules/element-plus/lib/hooks/use-model-toggle/index.js

@@ -0,0 +1,139 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var runtime = require('../../utils/vue/props/runtime.js');
+var types = require('../../utils/types.js');
+var shared = require('@vue/shared');
+var core = require('@vueuse/core');
+
+const _prop = runtime.buildProp({
+  type: runtime.definePropType(Boolean),
+  default: null
+});
+const _event = runtime.buildProp({
+  type: runtime.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 = vue.getCurrentInstance();
+    const { emit } = instance;
+    const props = instance.props;
+    const hasUpdateHandler = vue.computed(() => shared.isFunction(props[updateEventKeyRaw]));
+    const isModelBindingAbsent = vue.computed(() => props[name] === null);
+    const doShow = (event) => {
+      if (indicator.value === true) {
+        return;
+      }
+      indicator.value = true;
+      if (toggleReason) {
+        toggleReason.value = event;
+      }
+      if (shared.isFunction(onShow)) {
+        onShow(event);
+      }
+    };
+    const doHide = (event) => {
+      if (indicator.value === false) {
+        return;
+      }
+      indicator.value = false;
+      if (toggleReason) {
+        toggleReason.value = event;
+      }
+      if (shared.isFunction(onHide)) {
+        onHide(event);
+      }
+    };
+    const show = (event) => {
+      if (props.disabled === true || shared.isFunction(shouldProceed) && !shouldProceed())
+        return;
+      const shouldEmit = hasUpdateHandler.value && core.isClient;
+      if (shouldEmit) {
+        emit(updateEventKey, true);
+      }
+      if (isModelBindingAbsent.value || !shouldEmit) {
+        doShow(event);
+      }
+    };
+    const hide = (event) => {
+      if (props.disabled === true || !core.isClient)
+        return;
+      const shouldEmit = hasUpdateHandler.value && core.isClient;
+      if (shouldEmit) {
+        emit(updateEventKey, false);
+      }
+      if (isModelBindingAbsent.value || !shouldEmit) {
+        doHide(event);
+      }
+    };
+    const onChange = (val) => {
+      if (!types.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();
+      }
+    };
+    vue.watch(() => props[name], onChange);
+    if (shouldHideWhenRouteChanges && instance.appContext.config.globalProperties.$route !== void 0) {
+      vue.watch(() => ({
+        ...instance.proxy.$route
+      }), () => {
+        if (shouldHideWhenRouteChanges.value && indicator.value) {
+          hide();
+        }
+      });
+    }
+    vue.onMounted(() => {
+      onChange(props[name]);
+    });
+    return {
+      hide,
+      show,
+      toggle,
+      hasUpdateHandler
+    };
+  };
+  return {
+    useModelToggle: useModelToggle2,
+    useModelToggleProps: useModelToggleProps2,
+    useModelToggleEmits: useModelToggleEmits2
+  };
+};
+const { useModelToggle, useModelToggleProps, useModelToggleEmits } = createModelToggleComposable("modelValue");
+
+exports.createModelToggleComposable = createModelToggleComposable;
+exports.useModelToggle = useModelToggle;
+exports.useModelToggleEmits = useModelToggleEmits;
+exports.useModelToggleProps = useModelToggleProps;
+//# sourceMappingURL=index.js.map