fuse-code/src/store/floder-type.ts

import { computed, ref } from "vue";
import { fetchFloderTypes } from "@/api";

import type { FloderTypes, FloderType, Floder } from "@/api";
import { getFloderByType } from "./floder";
import { getUrlType, MetaType } from "@/utils";

export const floderTypes = ref<FloderTypes>([]);
export const getFloderType = (id: FloderType["filesTypeId"]) =>
  floderTypes.value.find((type) => type.filesTypeId === id);

export const initialFloderTypes = async () => {
  floderTypes.value = await fetchFloderTypes();
};

export type FloderRoot = {
  flat: boolean,
  modal: boolean
  id: number;
  title: string;
  floders: (ReturnType<typeof getFloderByType>[number] & { metaType: MetaType })[];
  children?: FloderRoot[];
};
const gemerateRoot = (parentId: number | null = null) => {
  const items: FloderRoot[] = [];
  for (let i = 0; i < floderTypes.value.length; i++) {
    const type = floderTypes.value[i];
    if (type.parentId === parentId || (type.parentId === undefined && parentId === null)) {
      const item = {
        id: type.filesTypeId,
        title: type.filesTypeName,
        flat: !!type.flatShow,
        modal: !!type.modalShow,
        floders: getFloderByType(type).map((floder) => {
          !floder.filesUrl &&console.log(floder.filesUrl)
          return{
          ...floder,
          metaType: floder.filesUrl && getUrlType(floder.filesUrl),
        }
        }),
        children: gemerateRoot(type.filesTypeId)
      };
      items.push(item)
    }
  }
  return items
};
export const floderRoots = computed(gemerateRoot);

export const getLevelRoot = (floder: Floder, roots = floderRoots.value): FloderRoot | undefined => {
  for (const root of roots) {
    if (root.floders.some(f => f.filesId === floder.filesId)) {
      return root;
    } else if (root.children?.length) {
      const cRoot = getLevelRoot(floder, root.children)
      if (cRoot) {
        return cRoot
      }
    }
  }
}

export const getFlatFloders = (root: FloderRoot, floders: FloderRoot['floders'] = []) => {
  floders.push(...root.floders)
  if (root.children?.length) {
    root.children.forEach(child => getFlatFloders(child, floders))
  }
  return floders
}

export type { FloderType, FloderTypes };