@vrx-arco/app/dist/index.mjs

<p align="center"> <img src="https://vrx-arco.github.io/arco-design-pro/favicon.svg" width="200" height="250"> </p>

import { defineComponent, computed, toRaw, inject, createApp } from 'vue';
import { createRouter, createWebHistory } from 'vue-router';
import { defineStore, storeToRefs, createPinia } from 'pinia';
import { useEmptyComponentInject, filterEmptyChildren } from '@vrx-arco/use';

var __defProp = Object.defineProperty;
var __defProps = Object.defineProperties;
var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
var __getOwnPropSymbols = Object.getOwnPropertySymbols;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __propIsEnum = Object.prototype.propertyIsEnumerable;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __spreadValues = (a, b) => {
  for (var prop in b || (b = {}))
    if (__hasOwnProp.call(b, prop))
      __defNormalProp(a, prop, b[prop]);
  if (__getOwnPropSymbols)
    for (var prop of __getOwnPropSymbols(b)) {
      if (__propIsEnum.call(b, prop))
        __defNormalProp(a, prop, b[prop]);
    }
  return a;
};
var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
var __async = (__this, __arguments, generator) => {
  return new Promise((resolve, reject) => {
    var fulfilled = (value) => {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    };
    var rejected = (value) => {
      try {
        step(generator.throw(value));
      } catch (e) {
        reject(e);
      }
    };
    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
    step((generator = generator.apply(__this, __arguments)).next());
  });
};
var usePermissionStore = defineStore("vrx-permission", {
  state: () => ({
    dynamicRoutesName: [],
    dynamicRoutes: [],
    permission: null
  }),
  actions: {
    setDynamicRoutesName(routesName) {
      this.dynamicRoutesName = [...routesName];
    }
  }
});

// src/pinia/index.ts
var definePinia = (app) => {
  const pinia = createPinia();
  app.use(pinia);
  return pinia;
};

// src/router/resetRoute.ts
var resetRoute = (router) => {
  const permissionStore = usePermissionStore();
  permissionStore.dynamicRoutesName.forEach((item) => {
    if (!router.hasRoute(item)) {
      return;
    }
    router.removeRoute(item);
  });
  permissionStore.dynamicRoutesName = [];
  permissionStore.dynamicRoutes = [];
};

// src/router/filterRoutes.ts
var filterRoutes = (routes, permission, filter) => {
  const filterRoutes2 = [];
  const nameList = /* @__PURE__ */ new Set();
  const listFilter = (routes2, filterRoutes3) => {
    routes2.forEach((item) => {
      const children = item.children;
      if (!item.name) {
        return;
      }
      nameList.add(item.name);
      if (!filter(item, permission)) {
        return;
      }
      if (!Array.isArray(children) || !children.length) {
        filterRoutes3.push(item);
        return;
      }
      const _filterRoute = __spreadProps(__spreadValues({}, item), { children: [] });
      filterRoutes3.push(_filterRoute);
      _filterRoute.children = listFilter(children, _filterRoute.children);
      return;
    });
    return filterRoutes3;
  };
  return [listFilter(routes, filterRoutes2), nameList];
};

// src/router/police.ts
var defineRouterPolice = (router, options) => {
  const { loading } = options;
  const {
    dynamicRoutes = [],
    filterDynamicRoutes = () => true,
    pageNotFound,
    whiteList = [],
    loginExpiredRedirect
  } = options.router;
  const { getPermission, onLoginExpired, isLogin = () => true } = options.authentication || {};
  router.beforeEach((to, _from, next) => __async(void 0, null, function* () {
    const permissionStore = usePermissionStore();
    loading == null ? void 0 : loading(true);
    const _isLogin = yield Promise.resolve().then(isLogin);
    if (!_isLogin) {
      resetRoute(router);
      if (to.name === loginExpiredRedirect || whiteList.includes(to.name)) {
        next();
        return;
      }
      next({ name: loginExpiredRedirect });
      return;
    }
    if (to.name === loginExpiredRedirect) {
      resetRoute(router);
      onLoginExpired == null ? void 0 : onLoginExpired();
      next();
      return;
    }
    if (!dynamicRoutes.length || permissionStore.dynamicRoutesName.length) {
      next();
      return;
    }
    try {
      const permission = yield Promise.resolve().then(getPermission);
      permissionStore.permission = permission;
      const [routes, routeNames] = filterRoutes(dynamicRoutes, permission, filterDynamicRoutes);
      permissionStore.setDynamicRoutesName(routeNames);
      routes.forEach((item) => {
        permissionStore.dynamicRoutes.push(item);
        router.addRoute(item);
      });
    } catch (e) {
      resetRoute(router);
      next({ name: loginExpiredRedirect });
      onLoginExpired == null ? void 0 : onLoginExpired();
    }
    if (to.name === pageNotFound.name) {
      next({ path: to.fullPath, replace: true, query: to.query });
      return;
    }
    next();
  }));
  router.afterEach(() => {
    loading == null ? void 0 : loading(false);
  });
};

// src/router/index.ts
var defineRouter = (app, options) => {
  const { routes, pageNotFound, options: routerOptions } = options.router;
  const router = createRouter(__spreadValues({
    history: createWebHistory(),
    routes: [...routes, __spreadValues({ path: "/:path(.*)*" }, pageNotFound)]
  }, routerOptions));
  defineRouterPolice(router, options);
  app.use(router);
  return router;
};
var VrxArcoPermissionContext = Symbol("VrxArcoPermissionContext");
var provideVrxArcoCheckPermission = (app, options) => {
  var _a;
  app.provide(
    VrxArcoPermissionContext,
    ((_a = options.authentication) == null ? void 0 : _a.checkPermission) || (() => true)
  );
};
var useVrxArcoCheckPermission = () => {
  return inject(VrxArcoPermissionContext, () => true);
};
var Permission = defineComponent({
  name: "vrx-arco-permission",
  props: {
    data: {},
    destroyOnNoPermission: {
      type: Boolean,
      default: true
    }
  },
  setup: (props, { slots }) => {
    const checkPermission = useVrxArcoCheckPermission();
    const { permission } = storeToRefs(usePermissionStore());
    const { empty } = useEmptyComponentInject();
    const hasPermission = computed(() => checkPermission(toRaw(permission.value), props.data));
    return () => {
      var _a, _b;
      empty.value = false;
      const { destroyOnNoPermission } = props;
      if (!hasPermission.value && destroyOnNoPermission) {
        const noPermission = filterEmptyChildren((_a = slots.noPermission) == null ? void 0 : _a.call(slots));
        empty.value = !noPermission.length;
        return noPermission;
      }
      return (_b = slots.default) == null ? void 0 : _b.call(slots, { hasPermission: hasPermission.value });
    };
  }
});

// src/index.ts
var createVrxArcoApp = (options) => {
  const { rootComponent, rootProps, rootContainer, immediate } = options;
  const app = createApp(rootComponent, rootProps);
  const pinia = definePinia(app);
  const router = defineRouter(app, options);
  provideVrxArcoCheckPermission(app, options);
  const mount = () => __async(void 0, null, function* () {
    yield router.isReady();
    return app.mount(rootContainer);
  });
  if (immediate != null ? immediate : true) {
    mount();
  }
  return { app, router, pinia, mount };
};

export { Permission, createVrxArcoApp, usePermissionStore };