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

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

'use strict';

var vue = require('vue');
var vueRouter = require('vue-router');
var pinia = require('pinia');
var use = require('@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 = pinia.defineStore("vrx-permission", {
  state: () => ({
    dynamicRoutesName: [],
    dynamicRoutes: [],
    permission: null
  }),
  actions: {
    setDynamicRoutesName(routesName) {
      this.dynamicRoutesName = [...routesName];
    }
  }
});

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

// 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 = vueRouter.createRouter(__spreadValues({
    history: vueRouter.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 vue.inject(VrxArcoPermissionContext, () => true);
};
var Permission = vue.defineComponent({
  name: "vrx-arco-permission",
  props: {
    data: {},
    destroyOnNoPermission: {
      type: Boolean,
      default: true
    }
  },
  setup: (props, { slots }) => {
    const checkPermission = useVrxArcoCheckPermission();
    const { permission } = pinia.storeToRefs(usePermissionStore());
    const { empty } = use.useEmptyComponentInject();
    const hasPermission = vue.computed(() => checkPermission(vue.toRaw(permission.value), props.data));
    return () => {
      var _a, _b;
      empty.value = false;
      const { destroyOnNoPermission } = props;
      if (!hasPermission.value && destroyOnNoPermission) {
        const noPermission = use.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 = vue.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 };
};

exports.Permission = Permission;
exports.createVrxArcoApp = createVrxArcoApp;
exports.usePermissionStore = usePermissionStore;