@ibiz-template/vue3-components 0.5.7-alpha.9 → 0.6.0-alpha.2

package/lib/web-app/components/router-shell/router-shell.cjs

@@ -0,0 +1,108 @@
+'use strict';
+
+var vue = require('vue');
+var vue3Util = require('@ibiz-template/vue3-util');
+var vueRouter = require('vue-router');
+var runtime = require('@ibiz-template/runtime');
+var core = require('@ibiz-template/core');
+var ramda = require('ramda');
+
+"use strict";
+const RouterShell = /* @__PURE__ */ vue.defineComponent({
+  name: "RouterShell",
+  props: {
+    modal: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props) {
+    const route = vueRouter.useRoute();
+    const router = vueRouter.useRouter();
+    const viewData = vue.ref({});
+    const isLoaded = vue.ref(false);
+    const isActivated = vue.ref(true);
+    const destroyContext = () => {
+      if (viewData.value.context) {
+        const {
+          context
+        } = vue.toRaw(viewData.value);
+        if (context)
+          context.destroy();
+      }
+    };
+    const routeDepth = props.modal.routeDepth;
+    vue.onUnmounted(() => {
+      destroyContext();
+    });
+    const calcViewData = async () => {
+      try {
+        const _viewData = await vue3Util.parseRouteViewData(route, routeDepth);
+        const _context = core.IBizContext.create(_viewData.context);
+        viewData.value = {
+          ..._viewData,
+          context: _context
+        };
+        isLoaded.value = true;
+      } catch (error) {
+        router.push({
+          name: "404View".concat(routeDepth)
+        });
+      }
+    };
+    calcViewData();
+    vue.watch(() => route.params.view1, () => {
+      if (routeDepth === 1) {
+        destroyContext();
+        calcViewData();
+      }
+    });
+    const routeModal = new runtime.Modal({
+      mode: runtime.ViewMode.ROUTE,
+      routeDepth: routeDepth + 1
+    });
+    vue.onActivated(() => {
+      isActivated.value = true;
+    });
+    vue.onDeactivated(() => {
+      isActivated.value = false;
+    });
+    return {
+      routeModal,
+      route,
+      viewData,
+      isLoaded,
+      isActivated
+    };
+  },
+  render() {
+    if (!this.isLoaded) {
+      return null;
+    }
+    const {
+      context,
+      params,
+      srfnav,
+      viewModel
+    } = this.viewData;
+    const props = ramda.mergeDeepLeft({
+      ...this.$props,
+      ...this.$attrs,
+      context,
+      params,
+      modelData: viewModel,
+      key: viewModel.codeName
+    }, {
+      state: {
+        srfnav
+      }
+    });
+    return vue.createVNode(vue.Fragment, null, [vue.h(vue.resolveComponent("IBizViewShell"), props, this.$slots), this.isActivated && vue.createVNode(vue.resolveComponent("router-view"), {
+      "key": viewModel.codeName,
+      "name": runtime.RouteConst.ROUTE_MODAL_TAG,
+      "modal": this.routeModal
+    }, null)]);
+  }
+});
+
+exports.RouterShell = RouterShell;

package/lib/web-app/create-vue-app.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+var vue = require('vue');
+var ElementPlus = require('element-plus');
+var zhCn = require('../node_modules/.pnpm/element-plus@2.4.2_vue@3.3.8/node_modules/element-plus/dist/locale/zh-cn.cjs');
+var vue3Util = require('@ibiz-template/vue3-util');
+var ibizVue3 = require('../ibiz-vue3.cjs');
+var index = require('../locale/index.cjs');
+
+"use strict";
+function createVueApp(rootComponent, rootProps) {
+  const app = vue.createApp(rootComponent, rootProps);
+  app.component("KeepAlive", vue.KeepAlive);
+  app.config.errorHandler = function(err) {
+    ibiz.util.error.handle(err);
+  };
+  const installPlugin = (_, plugin) => {
+    app.use(plugin);
+  };
+  vue3Util.AppHooks.useComponent.tap(installPlugin);
+  if (rootProps) {
+    const oldUnMounted = rootProps.unmounted;
+    rootProps.unmounted = () => {
+      oldUnMounted();
+      vue3Util.AppHooks.useComponent.removeTap(installPlugin);
+    };
+  }
+  app.use(index.i18n);
+  app.use(ElementPlus, {
+    locale: zhCn.default
+  });
+  app.use(vue3Util.piniaInstance);
+  app.use(ibizVue3.default);
+  vue3Util.AppHooks.createApp.callSync(null, app);
+  ibiz.plugin.register(app);
+  return app;
+}
+
+exports.createVueApp = createVueApp;

package/lib/web-app/guard/auth-guard/auth-guard.cjs

@@ -0,0 +1,171 @@
+'use strict';
+
+var core = require('@ibiz-template/core');
+var modelHelper = require('@ibiz-template/model-helper');
+var ramda = require('ramda');
+var vue3Util = require('@ibiz-template/vue3-util');
+var index = require('../../../locale/index.cjs');
+
+"use strict";
+async function loadAppData() {
+  const res = await ibiz.net.get("/appdata");
+  if (res.ok) {
+    ibiz.appData = res.data;
+  }
+}
+async function loadOrgData() {
+  const res = await ibiz.net.get("/uaa/getbydcsystem/".concat(ibiz.env.dcSystem));
+  if (res.ok) {
+    const orgDataItems = res.data;
+    if (orgDataItems) {
+      const [data] = orgDataItems;
+      ibiz.orgData = data;
+    }
+  }
+}
+async function loadTheme() {
+  const app = ibiz.hub.getApp();
+  const uiThemes = app.model.appUIThemes || [];
+  if (uiThemes.length > 0) {
+    const theme = uiThemes[0];
+    await ibiz.util.theme.loadTheme(theme);
+  }
+}
+async function initEnvironment(helper) {
+  if (helper) {
+    const app = await helper.getAppModel();
+    const userParam = app.userParam;
+    if (userParam) {
+      Object.keys(userParam).forEach((key) => {
+        const value = ibiz.util.rawValue.format(userParam[key]);
+        const keys = key.split(".");
+        let currentObj = ibiz.env;
+        for (let i = 0; i < keys.length; i++) {
+          const k = keys[i];
+          if (i === keys.length - 1) {
+            currentObj[k] = value;
+          } else {
+            currentObj[k] = currentObj[k] || {};
+            currentObj = currentObj[k];
+          }
+        }
+      });
+      if (ibiz.env.globalConfig) {
+        ibiz.config = ramda.mergeDeepRight(ibiz.config, ibiz.env.globalConfig);
+      }
+      ibiz.log.setLevel(ibiz.env.logLevel);
+    }
+  }
+}
+let hasModelInit = false;
+let noPermissionModel = false;
+async function initModel(permission = true) {
+  if (!hasModelInit || hasModelInit && noPermissionModel !== permission) {
+    ibiz.hub.reset();
+    const helper = new modelHelper.ModelHelper(
+      async (url, params) => {
+        const res = await ibiz.net.get(
+          "".concat(ibiz.env.remoteModelUrl).concat(url),
+          params,
+          permission ? {} : { srfdcsystem: ibiz.env.dcSystem }
+        );
+        return res.data;
+      },
+      ibiz.env.appId,
+      permission
+    );
+    await initEnvironment(helper);
+    const app = await ibiz.hub.getAppAsync(ibiz.env.appId);
+    const appModel = app.model;
+    ibiz.env.isMob = appModel.mobileApp === true;
+    if (ibiz.env.isEnableMultiLan) {
+      const lang = ibiz.i18n.getLang();
+      const m = await helper.getPSAppLang(lang.replace("-", "_").toUpperCase());
+      const items = m.languageItems || [];
+      const data = {};
+      items.forEach((item) => {
+        data[item.lanResTag] = item.content;
+      });
+      index.i18n.global.mergeLocaleMessage(lang, data);
+    }
+    if (!appModel.appUIThemes) {
+      const module = await import('@ibiz-template/web-theme');
+      const theme = module.default || module;
+      vue3Util.AppHooks.useComponent.callSync(null, theme);
+    } else {
+      await loadTheme();
+    }
+  }
+  noPermissionModel = permission;
+  hasModelInit = true;
+}
+async function appInit() {
+  if (ibiz.env.isSaaSMode === true) {
+    await loadOrgData();
+  }
+  await loadAppData();
+  await initModel();
+  await ibiz.auth.extendLogin();
+  await ibiz.hub.notice.init();
+}
+function throw401() {
+  throw new core.HttpError({
+    response: {
+      status: 401,
+      statusText: "\u65E0\u6743\u9650\u8BBF\u95EE\uFF01"
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  });
+}
+async function anonymousValidate() {
+  const authInfo = ibiz.auth.getAuthInfo();
+  if (authInfo && !authInfo.isAnonymous) {
+    return;
+  }
+  await initModel(false);
+  const urlPaths = window.location.hash.split("/");
+  const viewName = urlPaths[urlPaths.length - 2];
+  let viewModel;
+  if (viewName !== "#") {
+    try {
+      viewModel = await ibiz.hub.getAppView(viewName);
+    } catch (error) {
+      ibiz.log.error(error);
+    }
+  }
+  if (!viewModel) {
+    ibiz.log.error(
+      "\u627E\u4E0D\u5230\u89C6\u56FE\u6A21\u578B".concat(viewName, ",\u8BF7\u786E\u4FDD\u8BE5\u89C6\u56FE\u914D\u7F6E\u4E86\u533F\u540D\u8BBF\u95EE\u548C\u7528\u6237\u5F15\u7528")
+    );
+    throw401();
+    return;
+  }
+  if (viewModel.accUserMode !== 3) {
+    throw401();
+  }
+  if (!authInfo) {
+    const loginResult = await ibiz.auth.anonymousLogin();
+    if (!loginResult) {
+      throw new core.RuntimeError("\u533F\u540D\u7528\u6237\u767B\u5F55\u5931\u8D25");
+    }
+  }
+}
+async function AuthGuard(notLogin = true) {
+  if (notLogin) {
+    let result = true;
+    try {
+      if (ibiz.env.enableAnonymous) {
+        await anonymousValidate();
+      }
+      await appInit();
+    } catch (error) {
+      result = false;
+      ibiz.util.error.handle(error);
+    }
+    return result;
+  }
+  await initModel(false);
+  return true;
+}
+
+exports.AuthGuard = AuthGuard;

package/lib/web-app/guard/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var authGuard = require('./auth-guard/auth-guard.cjs');
+
+"use strict";
+
+exports.AuthGuard = authGuard.AuthGuard;

package/lib/web-app/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var main = require('./main.cjs');
+
+"use strict";
+
+exports.runApp = main.runApp;

package/lib/web-app/main.cjs

@@ -0,0 +1,65 @@
+'use strict';
+
+var core = require('@ibiz-template/core');
+var runtime = require('@ibiz-template/runtime');
+var vue3Util = require('@ibiz-template/vue3-util');
+var createVueApp = require('./create-vue-app.cjs');
+var attachEnvironmentConfig = require('./attach-environment-config.cjs');
+var App = require('./App.cjs');
+require('./util/index.cjs');
+var index = require('./router/index.cjs');
+require('../util/index.cjs');
+var openViewUtil = require('../util/open-view-util/open-view-util.cjs');
+var messageUtil = require('../util/message-util/message-util.cjs');
+var modalUtil = require('../util/modal-util/modal-util.cjs');
+var confirmUtil = require('../util/confirm-util/confirm-util.cjs');
+var notificationUtil = require('../util/notification-util/notification-util.cjs');
+var loadingUtil = require('../util/loading-util/loading-util.cjs');
+var noticeUtil = require('../util/notice-util/notice-util.cjs');
+var overlayController = require('../util/overlay-controller/overlay-controller.cjs');
+var unauthorizedHandler = require('./util/unauthorized-handler/unauthorized-handler.cjs');
+
+"use strict";
+async function runApp(plugins) {
+  vue3Util.AppHooks.createApp.tap((_, app2) => {
+    if (plugins) {
+      plugins.forEach((plugin) => {
+        app2.use(plugin);
+      });
+    }
+  });
+  core.install();
+  runtime.install();
+  ibiz.plugin = new vue3Util.PluginFactory();
+  const app = createVueApp.createVueApp(App.default);
+  vue3Util.OverlayContainer.createVueApp = createVueApp.createVueApp;
+  window.onerror = function(_event, _source, _lineno, _colno, error) {
+    if (error) {
+      ibiz.util.error.handle(error);
+    }
+  };
+  window.addEventListener("unhandledrejection", function(event) {
+    event.preventDefault();
+    event.promise.catch((err) => {
+      ibiz.util.error.handle(err);
+    });
+  });
+  await attachEnvironmentConfig.attachEnvironmentConfig();
+  app.use(index.AppRouter.getRouter());
+  ibiz.openView = new openViewUtil.OpenViewUtil(index.AppRouter.getRouter());
+  ibiz.message = new messageUtil.MessageUtil();
+  ibiz.modal = new modalUtil.ModalUtil();
+  ibiz.confirm = new confirmUtil.ConfirmUtil();
+  ibiz.notification = new notificationUtil.NotificationUtil();
+  ibiz.loading = new loadingUtil.LoadingUtil();
+  ibiz.notice = new noticeUtil.NoticeUtil();
+  ibiz.overlay = new overlayController.OverlayController();
+  ibiz.util.text.format = (value, code) => {
+    return app.config.globalProperties.$textFormat(value, code);
+  };
+  ibiz.util.error.register(new unauthorizedHandler.UnauthorizedHandler());
+  await ibiz.i18n.init();
+  app.mount("#app");
+}
+
+exports.runApp = runApp;

package/lib/web-app/router/index.cjs

@@ -0,0 +1,202 @@
+'use strict';
+
+var vueRouter = require('vue-router');
+var vue3Util = require('@ibiz-template/vue3-util');
+var runtime = require('@ibiz-template/runtime');
+var nprogress = require('../../node_modules/.pnpm/nprogress@0.2.0/node_modules/nprogress/nprogress.cjs');
+require('../guard/index.cjs');
+require('../../view/index.cjs');
+require('../components/index.cjs');
+require('nprogress/nprogress.css');
+var authGuard = require('../guard/auth-guard/auth-guard.cjs');
+var loginView = require('../../view/login-view/login-view.cjs');
+var _404View = require('../../view/404-view/404-view.cjs');
+var routerShell = require('../components/router-shell/router-shell.cjs');
+var modalRouterShell = require('../components/modal-router-shell/modal-router-shell.cjs');
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class AppRouter {
+  static getRouter() {
+    const placeholder = ibiz.env.routePlaceholder;
+    const paramReg = "[^/]+=[^/]+|".concat(placeholder);
+    const viewReg = "[^=/]+";
+    if (!this.router) {
+      this.router = vueRouter.createRouter({
+        // 4. 内部提供了 history 模式的实现。为了简单起见，我们在这里使用 hash 模式。
+        history: vueRouter.createWebHashHistory(),
+        routes: [
+          {
+            path: "/",
+            redirect: "/".concat(placeholder, "/index/").concat(placeholder)
+          },
+          {
+            path: "/login",
+            name: "loginView",
+            beforeEnter: async (_to, _from, next) => {
+              await authGuard.AuthGuard(false);
+              next();
+            },
+            component: loginView.LoginView
+          },
+          {
+            path: "/404",
+            name: "404View1",
+            component: _404View.View404
+          },
+          {
+            path: "/appredirectview",
+            name: "appRedirectView",
+            beforeEnter: async (_to, _from, next) => {
+              const authority = await authGuard.AuthGuard();
+              if (authority) {
+                next();
+              } else {
+                next(false);
+              }
+            },
+            component: vue3Util.AppRedirectView
+          },
+          {
+            path: "/:appContext(".concat(paramReg, ")/:view1(").concat(viewReg, ")/:params1(").concat(paramReg, ")"),
+            beforeEnter: async (_to, _from, next) => {
+              const authority = await authGuard.AuthGuard();
+              if (authority) {
+                next();
+              } else {
+                next(false);
+              }
+            },
+            component: routerShell.RouterShell,
+            children: [
+              {
+                path: "404",
+                name: "404View2",
+                component: _404View.View404
+              },
+              {
+                path: "".concat(runtime.RouteConst.ROUTE_MODAL_TAG, "/:modalView(").concat(viewReg, ")/:modalParams(").concat(paramReg, ")"),
+                components: {
+                  [runtime.RouteConst.ROUTE_MODAL_TAG]: modalRouterShell.ModalRouterShell
+                }
+              },
+              {
+                path: ":view2(".concat(viewReg, ")/:params2(").concat(paramReg, ")"),
+                component: routerShell.RouterShell,
+                children: [
+                  {
+                    path: "404",
+                    name: "404View3",
+                    component: _404View.View404
+                  },
+                  {
+                    path: "".concat(runtime.RouteConst.ROUTE_MODAL_TAG, "/:modalView(").concat(viewReg, ")/:modalParams(").concat(paramReg, ")"),
+                    components: {
+                      [runtime.RouteConst.ROUTE_MODAL_TAG]: modalRouterShell.ModalRouterShell
+                    }
+                  },
+                  {
+                    path: ":view3(".concat(viewReg, ")/:params3(").concat(paramReg, ")"),
+                    component: routerShell.RouterShell,
+                    children: [
+                      {
+                        path: "404",
+                        name: "404View4",
+                        component: _404View.View404
+                      },
+                      {
+                        path: "".concat(runtime.RouteConst.ROUTE_MODAL_TAG, "/:modalView(").concat(viewReg, ")/:modalParams(").concat(paramReg, ")"),
+                        components: {
+                          [runtime.RouteConst.ROUTE_MODAL_TAG]: modalRouterShell.ModalRouterShell
+                        }
+                      },
+                      {
+                        path: ":view4(".concat(viewReg, ")/:params4(").concat(paramReg, ")"),
+                        component: routerShell.RouterShell,
+                        children: [
+                          {
+                            path: "404",
+                            name: "404View5",
+                            component: _404View.View404
+                          },
+                          {
+                            path: "".concat(runtime.RouteConst.ROUTE_MODAL_TAG, "/:modalView(").concat(viewReg, ")/:modalParams(").concat(paramReg, ")"),
+                            components: {
+                              [runtime.RouteConst.ROUTE_MODAL_TAG]: modalRouterShell.ModalRouterShell
+                            }
+                          },
+                          {
+                            path: ":view5(".concat(viewReg, ")/:params5(").concat(paramReg, ")"),
+                            component: routerShell.RouterShell,
+                            children: [
+                              {
+                                path: "404",
+                                name: "404View6",
+                                component: _404View.View404
+                              },
+                              {
+                                path: "".concat(runtime.RouteConst.ROUTE_MODAL_TAG, "/:modalView(").concat(viewReg, ")/:modalParams(").concat(paramReg, ")"),
+                                components: {
+                                  [runtime.RouteConst.ROUTE_MODAL_TAG]: modalRouterShell.ModalRouterShell
+                                }
+                              },
+                              {
+                                path: ":view6(".concat(viewReg, ")/:params6(").concat(paramReg, ")"),
+                                component: routerShell.RouterShell
+                              },
+                              {
+                                path: ":pathMatch(.*)*",
+                                redirect: { name: "404View6" }
+                              }
+                            ]
+                          },
+                          {
+                            path: ":pathMatch(.*)*",
+                            redirect: { name: "404View6" }
+                          }
+                        ]
+                      },
+                      {
+                        path: ":pathMatch(.*)*",
+                        redirect: { name: "404View4" }
+                      }
+                    ]
+                  },
+                  {
+                    path: ":pathMatch(.*)*",
+                    redirect: { name: "404View3" }
+                  }
+                ]
+              },
+              {
+                path: ":pathMatch(.*)*",
+                redirect: { name: "404View2" }
+              }
+            ]
+          },
+          {
+            path: "/:pathMatch(.*)*",
+            redirect: { name: "404View1" }
+          }
+        ]
+      });
+      this.router.beforeEach((_to, _from, next) => {
+        nprogress.default.configure({ showSpinner: false });
+        nprogress.default.start();
+        next();
+      });
+      this.router.afterEach(() => {
+        nprogress.default.done();
+      });
+    }
+    return this.router;
+  }
+}
+__publicField(AppRouter, "router");
+
+exports.AppRouter = AppRouter;

package/lib/web-app/util/index.cjs

@@ -0,0 +1,7 @@
+'use strict';
+
+var unauthorizedHandler = require('./unauthorized-handler/unauthorized-handler.cjs');
+
+"use strict";
+
+exports.UnauthorizedHandler = unauthorizedHandler.UnauthorizedHandler;