@ctzy-web-client/web-base-client-vue 1.0.1

package/lib/application/Application2.js

@@ -0,0 +1,46 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var tokens = require('@ctzy-web-client/tokens');
+var vueRouter = require('vue-router');
+require('../hooks/index.js');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+var index = require('../hooks/use-namespace/index.js');
+var index$1 = require('../hooks/use-global-config/index.js');
+
+const __default__ = vue.defineComponent({
+  name: "BwaApplication"
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    application: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const ns = index.useNamespace("application");
+    vue.watch(
+      vueRouter.useRoute(),
+      (currentRoute) => {
+        props.application.emitParentApplication("route-change", currentRoute);
+      },
+      { immediate: true }
+    );
+    vue.provide(tokens.applicationKey, vue.ref(props.application));
+    index$1.provideGlobalConfig({ [tokens.applicationKey]: props.application }, null, true);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        class: vue.normalizeClass(vue.unref(ns).b())
+      }, [
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 2);
+    };
+  }
+});
+var Application = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "application.vue"]]);
+
+exports["default"] = Application;

package/lib/application/MicroApplication.js

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var qiankun = require('qiankun');
+
+class MicroApplication {
+  constructor(options, application) {
+    options = options || {};
+    this.name = options.name;
+    this.entry = options.entry;
+    this.extendOptions = (options == null ? void 0 : options.extendOptions) || {};
+    this.ownerApplication = application;
+    this._microApp = null;
+    this.container = null;
+  }
+  _loadMicroApp() {
+    return qiankun.loadMicroApp({
+      name: this.name,
+      entry: this.entry,
+      container: this.container,
+      props: {
+        extendOptions: this.extendOptions,
+        ownerApplication: this.ownerApplication
+      }
+    });
+  }
+  async mountApplication() {
+    var _a;
+    if (((_a = this._microApp) == null ? void 0 : _a.getStatus()) === "UNMOUNTING") {
+      await this._microApp.unmountPromise();
+    }
+    if (!this._microApp) {
+      this.container = document.createElement("div");
+      this._microApp = this._loadMicroApp();
+    }
+    await this._microApp.mountPromise;
+    if (this._microApp.getStatus() === "NOT_MOUNTED") {
+      await this._microApp.mount();
+    }
+  }
+  async unmountApplication() {
+    if (!this._microApp) {
+      return;
+    }
+    if (this._microApp.getStatus() !== "MOUNTED") {
+      await this._microApp.mountPromise;
+    }
+    await this._microApp.unmount();
+  }
+}
+
+exports.MicroApplication = MicroApplication;

package/lib/application/app.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var application = require('./application2.js');
+var vueRouter = require('vue-router');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+
+const _sfc_main = {
+  __name: "app",
+  props: {
+    applicaiton: {
+      Object,
+      required: true
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const { applicaiton } = vue.toRefs(props);
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(application["default"], { application: vue.unref(applicaiton) }, {
+        default: vue.withCtx(() => [
+          (vue.openBlock(), vue.createBlock(vue.Suspense, null, {
+            default: vue.withCtx(() => [
+              vue.createVNode(vue.unref(vueRouter.RouterView))
+            ]),
+            _: 1
+          }))
+        ]),
+        _: 1
+      }, 8, ["application"]);
+    };
+  }
+};
+var App = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "app.vue"]]);
+
+exports["default"] = App;

package/lib/application/application.js

@@ -0,0 +1,316 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var vueRouter = require('vue-router');
+var support = require('@ctzy-web-client/support');
+var ioc = require('@ctzy-web-client/ioc');
+var dataModel = require('@ctzy-web-client/data-model');
+var MicroApplication = require('./MicroApplication.js');
+require('../utils/index.js');
+var app = require('./app.js');
+require('../interceptors/index.js');
+require('../ioc/index.js');
+var ReactiveInstantiationService = require('../ioc/ReactiveInstantiationService.js');
+var RequestInterceptors = require('../interceptors/RequestInterceptors.js');
+var RouterInterceptors = require('../interceptors/RouterInterceptors.js');
+var pageDataParser = require('../utils/pageDataParser.js');
+
+class Application extends support.EventDispatcher {
+  constructor(appName, options) {
+    super();
+    this.appName = appName;
+    this.options = options || {};
+    this._app = null;
+    this._router = null;
+    this._history = null;
+    this._iocContainer = new ioc.IocContainer();
+    this.parent = null;
+    this.microApplications = [];
+    this.subApplications = [];
+    this._targetSelector = "";
+    this._extendOptions = null;
+    this._plugins = [];
+    this.global = options.global;
+    this.applicationSlots = /* @__PURE__ */ new Map();
+    if (!this.global) {
+      throw new Error("options.global \u4E0D\u5B58\u5728");
+    }
+    this._viewportMountPromise = null;
+    this.global.__INNER_APPLICATION__ = this;
+    this._initEvent();
+    this._initIocContainer();
+    this._setRequestInterceptors();
+    this._exportLifecycle();
+    this._resolveRoutesPromise = null;
+    this._mountResolve = null;
+  }
+  addApplicationSlot(type, id, slot) {
+    let withTypeSlots = this.applicationSlots.get(type);
+    if (!withTypeSlots) {
+      withTypeSlots = /* @__PURE__ */ new Map();
+      this.applicationSlots.set(type, withTypeSlots);
+    }
+    withTypeSlots.set(id, slot);
+    this.emit("slot-change", type);
+    this.emitParentApplication("slot-change", type);
+  }
+  removeApplicationSlot(type, id) {
+    const withTypeSlots = this.applicationSlots.get(type);
+    if (!withTypeSlots) {
+      return;
+    }
+    withTypeSlots.delete(id);
+    this.emit("slot-change", type);
+    this.emitParentApplication("slot-change", type);
+  }
+  getApplicationSlots(type) {
+    let withTypeSlots = this.applicationSlots.get(type);
+    if (!withTypeSlots) {
+      return [];
+    }
+    return Array.from(withTypeSlots.values());
+  }
+  getIocContainer() {
+    return this._iocContainer;
+  }
+  getInstantiationService() {
+    return this.getIocContainer().getService(ioc.InstantiationService);
+  }
+  createInstance(Clazz, options) {
+    return this.getInstantiationService().createInstance(Clazz, options);
+  }
+  _initIocContainer() {
+    this._iocContainer.setInstantiationService(ReactiveInstantiationService.ReactiveInstantiationService);
+    this._iocContainer.registerService(RequestInterceptors.RequestInterceptors, RequestInterceptors.RequestInterceptors, {
+      overwrite: true
+    });
+    this._iocContainer.registerService(RouterInterceptors.RouterInterceptors, RouterInterceptors.RouterInterceptors, {
+      overwrite: true
+    });
+    this._iocContainer.registerService(support.HttpRequest, support.HttpRequest, {
+      overwrite: true,
+      args: [this.options.request || {}]
+    });
+    this._iocContainer.registerService(dataModel.SimpleOrm, dataModel.SimpleOrm, {
+      overwrite: false
+    });
+    this._iocContainer.registerService(dataModel.DataModelAdapter, dataModel.DataModelAdapter, {
+      overwrite: false
+    });
+    this._iocContainer.registerService("Application", Application, {
+      overwrite: false
+    });
+    this._iocContainer._serviceCollection.setInstance("Application", this);
+    this._iocContainer.registerValue("AppName", this.appName || "");
+    const delayRegisterServices = this.global.__DELAY_REGISTER_SERVICES__ || [];
+    for (const Service of delayRegisterServices) {
+      const serviceOptions = Service[ioc.SERVICE_INFO];
+      this._iocContainer.registerService(serviceOptions.value, Service, serviceOptions);
+    }
+    Reflect.deleteProperty(this.global, "__DELAY_REGISTER_SERVICES__");
+  }
+  _setRequestInterceptors() {
+    const httpRequest = this._iocContainer.getService(support.HttpRequest);
+    const requestInterceptors = this._iocContainer.getService(RequestInterceptors.RequestInterceptors);
+    httpRequest.setOptions(this.options.request);
+    httpRequest.addRequestInterceptors(requestInterceptors.request.bind(requestInterceptors), requestInterceptors.requestError.bind(requestInterceptors));
+    httpRequest.addResponseInterceptors(requestInterceptors.response.bind(requestInterceptors), requestInterceptors.requestError.bind(requestInterceptors));
+  }
+  _setRouteInterceptors() {
+    const routerInterceptors = this._iocContainer.getService(RouterInterceptors.RouterInterceptors);
+    this._router.beforeEach(routerInterceptors.beforeEach.bind(routerInterceptors));
+    this._router.beforeResolve(routerInterceptors.beforeResolve.bind(routerInterceptors));
+    this._router.afterEach(routerInterceptors.afterEach.bind(routerInterceptors));
+  }
+  _initVue() {
+    this._app = vue.createApp({
+      setup: () => {
+        const applicaiton = vue.reactive(this);
+        return () => vue.h(this.options.app || app["default"], {
+          applicaiton
+        });
+      }
+    });
+    this._plugins.forEach((plugin) => {
+      this._app.use(plugin);
+    });
+  }
+  _initRouter() {
+    var _a;
+    if (!this._app) {
+      throw new Error("Vue\u5B9E\u4F8B\u4E0D\u5B58\u5728");
+    }
+    let history = null;
+    let base = this.options.routeBaseUrl || "/";
+    if (this.global.__POWERED_BY_QIANKUN__ && base === "/") {
+      base = `/${this.appName}`;
+    }
+    if ((_a = this._extendOptions) == null ? void 0 : _a.base) {
+      base = this._extendOptions.base + base;
+    }
+    switch (this.options.routeMode) {
+      case "hash":
+        history = vueRouter.createWebHashHistory(base);
+        break;
+      case "memory":
+        history = vueRouter.createMemoryHistory(base);
+        break;
+      default:
+        history = vueRouter.createWebHistory(base);
+    }
+    this._history = history;
+    this._router = vueRouter.createRouter({
+      history,
+      routes: []
+    });
+    this._setRouteInterceptors();
+    this._app.use(this._router);
+  }
+  async _resolveRoutes() {
+    let pageDefines = await pageDataParser.pageDataParser(this.options.pages);
+    if (!this._router) {
+      return;
+    }
+    pageDefines = pageDefines.filter((pageDefine) => typeof pageDefine.name === "string" && typeof pageDefine.route === "string");
+    const routes = pageDefines.map((define) => ({
+      name: define.name,
+      redirect: define.redirect,
+      path: define.route,
+      props: define.props || ((route) => Object.assign(route.params, route.query)),
+      meta: define.meta,
+      component: define.component,
+      children: []
+    }));
+    const rootRoutes = [];
+    for (let i = 0, length = routes.length; i < length; i++) {
+      const pageDefine = pageDefines[i];
+      const route = routes[i];
+      for (let j = 0; j < length; j++) {
+        if (i === j) {
+          continue;
+        }
+        const innerPageDefine = pageDefines[j];
+        const innerRoute = routes[j];
+        if (pageDefine.name == null || innerPageDefine.name == null) {
+          continue;
+        }
+        if (pageDefine.name === innerPageDefine.parent) {
+          route.children.push(innerRoute);
+        }
+      }
+      if (!pageDefine.parent) {
+        rootRoutes.push(route);
+      }
+    }
+    for (const rootRoute of rootRoutes) {
+      this._router.addRoute(rootRoute);
+    }
+  }
+  _initEvent() {
+    this.on("subApplicationCreate", (application) => {
+      this.subApplications.push(application);
+    });
+    this.on("subApplicationDestroy", (application) => {
+      this.subApplications = this.subApplications.filter((app) => app !== application);
+    });
+  }
+  _exportLifecycle() {
+    if (!this.global.__POWERED_BY_QIANKUN__ || !this.appName) {
+      this._viewportMountPromise = Promise.resolve();
+      return;
+    }
+    if (!this.global.moudleQiankunAppLifeCycles) {
+      this.global.moudleQiankunAppLifeCycles = {};
+    }
+    this.global.moudleQiankunAppLifeCycles[this.appName] = {
+      bootstrap: async (props) => {
+      },
+      mount: async ({
+        ownerApplication,
+        container,
+        extendOptions = {}
+      }) => {
+        var _a;
+        this.parent = ownerApplication || null;
+        this._extendOptions = extendOptions;
+        this._initVue();
+        this._initRouter();
+        if (ownerApplication) {
+          this._iocContainer.setParent(ownerApplication.getIocContainer());
+        }
+        if (this._targetSelector) {
+          this._app.mount(container.querySelector(this._targetSelector));
+        }
+        this._resolveRoutesPromise = this._resolveRoutes();
+        this._resolveRoutesPromise.then(() => {
+          this._resolveRoutesPromise = null;
+        });
+        if (typeof this._mountResolve === "function") {
+          this._mountResolve();
+        }
+        (_a = this.parent) == null ? void 0 : _a.emit("subApplicationCreate", this);
+      },
+      unmount: async () => {
+        var _a;
+        (_a = this.parent) == null ? void 0 : _a.emit("subApplicationDestroy", this);
+        this.parent = null;
+        this._history.destroy();
+        this._app.unmount();
+        this._app = null;
+        this._router = null;
+        this._extendOptions = null;
+        this._iocContainer.setParent(null);
+        if (this._targetSelector) {
+          this.unmount();
+        }
+      }
+    };
+  }
+  getMicroApplication(name) {
+    var _a;
+    return (_a = this.microApplications.find((microApplication) => microApplication.name === name)) != null ? _a : null;
+  }
+  createMicroApplication(options) {
+    const microApplication = new MicroApplication.MicroApplication(options, this);
+    this.microApplications.push(microApplication);
+    return microApplication;
+  }
+  emitParentApplication(eventName, ...args) {
+    if (!this.parent) {
+      return;
+    }
+    this.parent.emit("fromSubApplication", this.appName, eventName, ...args);
+  }
+  use(plugin) {
+    this._plugins.push(plugin);
+    return this;
+  }
+  async mount(target) {
+    if (typeof target !== "string") {
+      throw new Error("mount: \u6307\u63A5\u53D7\u5B57\u7B26\u4E32\u53C2\u6570\u3002");
+    }
+    if (this.global.__POWERED_BY_QIANKUN__) {
+      const mountPromise = new Promise((resolve) => {
+        this._mountResolve = resolve;
+      });
+      this._targetSelector = target;
+      await mountPromise;
+      return;
+    }
+    this._initVue();
+    this._initRouter();
+    this._app.mount(target);
+    this._resolveRoutesPromise = this._resolveRoutes();
+    this._resolveRoutesPromise.then(() => {
+      this._resolveRoutesPromise = null;
+    });
+  }
+  unmount() {
+    var _a;
+    (_a = this._app) == null ? void 0 : _a.unmount();
+  }
+}
+
+exports.Application = Application;

package/lib/application/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var install = require('element-plus/es/utils/vue/install');
+var application = require('./application2.js');
+var microApplication = require('./micro-application.js');
+var Application = require('./Application.js');
+
+const BwaApplication = install.withInstall(application["default"], {
+  MicroApplication: microApplication["default"]
+});
+const BwaMicroApplication = install.withInstall(microApplication["default"]);
+
+exports.Application = Application.Application;
+exports.BwaApplication = BwaApplication;
+exports.BwaMicroApplication = BwaMicroApplication;
+exports["default"] = BwaApplication;

package/lib/application/micro-application.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var tokens = require('@ctzy-web-client/tokens');
+require('../hooks/index.js');
+var _pluginVue_exportHelper = require('../_virtual/_plugin-vue_export-helper.js');
+var index = require('../hooks/use-namespace/index.js');
+var index$1 = require('../hooks/use-global-config/index.js');
+
+const __default__ = vue.defineComponent({
+  name: "BwaMcrioApplication"
+});
+const _sfc_main = /* @__PURE__ */ Object.assign(__default__, {
+  props: {
+    name: {
+      type: String,
+      required: true
+    },
+    entry: {
+      type: String,
+      required: true
+    },
+    extendOptions: {
+      type: Object
+    }
+  },
+  async setup(__props) {
+    let __temp, __restore;
+    const props = __props;
+    const ns = index.useNamespace("application");
+    const application = index$1.useGlobalConfig(tokens.applicationKey);
+    const el = vue.ref(null);
+    const microApplication = vue.computed(
+      () => application.value.getMicroApplication(props.name) || application.value.createMicroApplication({
+        name: props.name,
+        entry: props.entry,
+        extendOptions: props.extendOptions
+      })
+    );
+    const mountApplicationPromise = microApplication.value.mountApplication();
+    vue.onMounted(() => {
+      el.value.appendChild(microApplication.value.container);
+    });
+    vue.onBeforeUnmount(() => {
+      el.value.removeChild(microApplication.value.container);
+      microApplication.value.unmountApplication();
+    });
+    ;
+    [__temp, __restore] = vue.withAsyncContext(() => mountApplicationPromise), await __temp, __restore();
+    return (_ctx, _cache) => {
+      return _cache[0] || (vue.setBlockTracking(-1), _cache[0] = vue.createElementVNode("div", {
+        ref_key: "el",
+        ref: el,
+        class: vue.normalizeClass(vue.unref(ns).b("mcrio"))
+      }, null, 2), vue.setBlockTracking(1), _cache[0]);
+    };
+  }
+});
+var MicroApplication = /* @__PURE__ */ _pluginVue_exportHelper["default"](_sfc_main, [["__file", "micro-application.vue"]]);
+
+exports["default"] = MicroApplication;

package/lib/constants/index.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/lib/hooks/index.js

@@ -0,0 +1,30 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('./use-global-config/index.js');
+var index$1 = require('./use-namespace/index.js');
+var index$2 = require('./use-data-form/index.js');
+var index$3 = require('./use-data-table/index.js');
+var index$4 = require('./use-service/index.js');
+var index$5 = require('./use-value/index.js');
+require('./use-keydown/index.js');
+var index$6 = require('./use-event-dispatcher/index.js');
+var index$7 = require('./use-data-table-page/index.js');
+var useKeydown = require('./use-keydown/use-keydown.js');
+var useSaveKeydown = require('./use-keydown/use-save-keydown.js');
+
+
+
+exports.provideGlobalConfig = index.provideGlobalConfig;
+exports.useGlobalConfig = index.useGlobalConfig;
+exports.defaultNamespace = index$1.defaultNamespace;
+exports.useNamespace = index$1.useNamespace;
+exports.useDataForm = index$2.useDataForm;
+exports.useDataTable = index$3.useDataTable;
+exports.useService = index$4.useService;
+exports.useValue = index$5.useValue;
+exports.useEventDispatcher = index$6.useEventDispatcher;
+exports.useDataTablePage = index$7.useDataTablePage;
+exports.useKeydown = useKeydown.useKeydown;
+exports.useSaveKeydown = useSaveKeydown.useSaveKeydown;

package/lib/hooks/use-data-form/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dataModel = require('@ctzy-web-client/data-model');
+var tokens = require('@ctzy-web-client/tokens');
+var index = require('../use-global-config/index.js');
+
+const useDataForm = (model, options = {}) => {
+  const application = index.useGlobalConfig(tokens.applicationKey);
+  const dataForm = vue.ref(application.value.createInstance(dataModel.DataForm, {
+    args: [{
+      model,
+      ...options
+    }]
+  }));
+  dataForm.value.init();
+  return dataForm;
+};
+
+exports.useDataForm = useDataForm;

package/lib/hooks/use-data-table/index.js

@@ -0,0 +1,22 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var dataModel = require('@ctzy-web-client/data-model');
+var tokens = require('@ctzy-web-client/tokens');
+var index = require('../use-global-config/index.js');
+
+const useDataTable = (model, options = {}) => {
+  const application = index.useGlobalConfig(tokens.applicationKey);
+  const dataTable = vue.ref(application.value.createInstance(dataModel.DataTable, {
+    args: [{
+      model,
+      ...options
+    }]
+  }));
+  dataTable.value.init();
+  return dataTable;
+};
+
+exports.useDataTable = useDataTable;

package/lib/hooks/use-data-table-page/index.js

@@ -0,0 +1,51 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+var vueRouter = require('vue-router');
+var index = require('../use-event-dispatcher/index.js');
+
+const useDataTablePage = (dataTable, options = {}) => {
+  options = {
+    ...options
+  };
+  options.currentPage = options.currentPage || "currentPage";
+  options.pageSize = options.pageSize || "pageSize";
+  const router = vueRouter.useRouter();
+  const route = vueRouter.useRoute();
+  let {
+    currentPage = vue.unref(dataTable).pageNum,
+    pageSize = vue.unref(dataTable).pageSize
+  } = vue.unref(route).query;
+  currentPage = parseInt(currentPage);
+  pageSize = parseInt(pageSize);
+  if (isNaN(currentPage)) {
+    currentPage = vue.unref(dataTable).pageNum;
+  }
+  if (isNaN(pageSize)) {
+    pageSize = vue.unref(dataTable).pageSize;
+  }
+  vue.unref(dataTable).pageNum = currentPage;
+  vue.unref(dataTable).pageSize = pageSize;
+  index.useEventDispatcher(dataTable, "current-page-change", (currentPage2) => {
+    const query = vue.unref(router.currentRoute).query;
+    router.replace({
+      query: {
+        ...query,
+        currentPage: currentPage2
+      }
+    });
+  });
+  index.useEventDispatcher(dataTable, "page-size-change", (pageSize2) => {
+    const query = vue.unref(router.currentRoute).query;
+    router.replace({
+      query: {
+        ...query,
+        pageSize: pageSize2
+      }
+    });
+  });
+};
+
+exports.useDataTablePage = useDataTablePage;

package/lib/hooks/use-event-dispatcher/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var vue = require('vue');
+
+const useEventDispatcher = (eventDispatcher, eventName, handler) => {
+  vue.onMounted(() => {
+    vue.unref(eventDispatcher).on(eventName, handler);
+  });
+  const off = () => {
+    vue.unref(eventDispatcher).off(eventName, handler);
+  };
+  vue.onUnmounted(off);
+  return off;
+};
+
+exports.useEventDispatcher = useEventDispatcher;