yanzhen-design-vue/es/components/contacts/src/list/use-contacts-list.mjs

import { useAttrs, useSlots, toRefs, computed, unref, mergeProps } from "vue";
import { createReusableTemplate } from "@vueuse/core";
import { useVModel, useOptionKey } from "@yanzhen-libs/utils-vue";
import { flattenDeep, pick } from "lodash-es";
import { isEmptyArray } from "@yanzhen-libs/utils";
import "../../../../utils/index.mjs";
import "../../../list/index.mjs";
import { Contacts } from "../constants/contacts.mjs";
import { handleTreeNode } from "../utils/handleTreeNode.mjs";
import { handleDataType } from "../utils/handleDataType.mjs";
import { listProps } from "../../../list/src/list.mjs";
import { message } from "../../../../utils/log.mjs";
const useContactsList = (props, emit) => {
  const $attrs = useAttrs();
  const $slots = useSlots();
  const { selectedIds, selectedValue, multiple, activeTab, ...refs } = toRefs(props);
  const _loading = useVModel(props, "loading", emit);
  const _childActiveTab = useVModel(props, "childActiveTab", emit);
  const _selectedIds = computed(() => {
    if (unref(selectedValue)) {
      const values = flattenDeep([unref(selectedValue)]);
      if (!unref(activeTab)) return values.map((item) => item.value);
      return values.reduce(
        (prev, item) => {
          const type = handleDataType(item);
          switch (true) {
            case type === unref(activeTab):
            case (unref(activeTab) === Contacts.USUALLY && [Contacts.USUALLY, Contacts.USER].includes(type)):
              prev.push(item.value);
              break;
          }
          return prev;
        },
        []
      );
    }
    return flattenDeep([unref(selectedIds)]).filter(Boolean);
  });
  const [DefineHeaderTemplate, ReusableHeaderTemplate] = createReusableTemplate();
  const [DefineContactsItemTemplate, ReusableContactsItemTemplate] = createReusableTemplate();
  const [DefineContactsCardItemTemplate, ReusableContactsCardItemTemplate] = createReusableTemplate();
  const [DefineSelectedIconTemplate, ReusableSelectedIconTemplate] = createReusableTemplate();
  const [DefineTreeTemplate, ReusableTreeTemplate] = createReusableTemplate();
  const [DefineTreeItemTemplate, ReusableTreeItemTemplate] = createReusableTemplate();
  const _listProps = computed(
    () => pick(mergeProps($attrs, unref(props)), ...Object.keys(listProps))
  );
  const _disabledIds = computed(() => flattenDeep([props.disableIds]));
  const selectedIconClass = computed(() => {
    return mergeProps(
      {
        class: []
      },
      {
        class: props.selectedIconClass
      }
    ).class;
  });
  function handleUpdateChildActiveTab(value) {
    if (props["onUpdate:childActiveTab"]) {
      props["onUpdate:childActiveTab"](value);
    } else {
      emit("update:child-active-tab", value);
    }
  }
  const optionKey = useOptionKey();
  const listConfig = computed(() => {
    return mergeProps(unref(_listProps), {
      "onUpdate:loading": props["onUpdate:loading"],
      onLoadMore: props.onLoadMore
    });
  });
  function handleLoadMore(...args) {
    if (props.onLoadMore) {
      props.onLoadMore(...args);
    } else {
      emit("load-more", ...args);
    }
  }
  async function handleTreeExpand(...args) {
    if (props.onTreeExpand) {
      props.onTreeExpand(...args);
    } else {
      emit("tree-expand", ...args);
    }
  }
  function handleTreeSelect(...args) {
    const [, info] = args;
    if ((info == null ? void 0 : info.node) && props.onItemClick) {
      handleItemClick(info == null ? void 0 : info.node);
      return;
    }
    if (props.onTreeSelect) {
      props.onTreeSelect(...args);
    } else {
      emit("tree-select", ...args);
    }
  }
  function handleItemClick(item) {
    switch (true) {
      case item.disabled:
      case item.disableCheckbox:
      case unref(_disabledIds).includes(item.value):
        return;
    }
    switch (unref(activeTab)) {
      case Contacts.USER:
        if (!item.isCard && isEmptyArray(item.children)) {
          message.warning("请展开数据").then((r) => r);
          return;
        }
        break;
    }
    if (props.onItemClick) {
      props.onItemClick(item);
    } else {
      emit("item-click", item);
    }
  }
  const ctx = {
    ...refs,
    multiple,
    activeTab,
    optionKey,
    _loading,
    _disabledIds,
    _selectedIds,
    _listProps,
    _childActiveTab,
    selectedIconClass,
    listConfig,
    $slots
  };
  const templates = {
    DefineHeaderTemplate,
    ReusableHeaderTemplate,
    DefineContactsItemTemplate,
    ReusableContactsItemTemplate,
    DefineContactsCardItemTemplate,
    ReusableContactsCardItemTemplate,
    DefineSelectedIconTemplate,
    ReusableSelectedIconTemplate,
    DefineTreeTemplate,
    ReusableTreeTemplate,
    DefineTreeItemTemplate,
    ReusableTreeItemTemplate
  };
  return {
    ctx,
    templates,
    handleTreeNode,
    handleItemClick,
    handleTreeSelect,
    handleTreeExpand,
    handleLoadMore,
    handleUpdateChildActiveTab
  };
};
export {
  useContactsList
};