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

package/es/application/Application2.mjs

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

package/es/application/MicroApplication.mjs

@@ -0,0 +1,49 @@
+import { loadMicroApp } from '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 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();
+  }
+}
+
+export { MicroApplication };

package/es/application/app.mjs

@@ -0,0 +1,34 @@
+import { toRefs, openBlock, createBlock, unref, withCtx, Suspense, createVNode } from 'vue';
+import Application from './application2.mjs';
+import { RouterView } from 'vue-router';
+import _export_sfc from '../_virtual/_plugin-vue_export-helper.mjs';
+
+const _sfc_main = {
+  __name: "app",
+  props: {
+    applicaiton: {
+      Object,
+      required: true
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const { applicaiton } = toRefs(props);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(Application, { application: unref(applicaiton) }, {
+        default: withCtx(() => [
+          (openBlock(), createBlock(Suspense, null, {
+            default: withCtx(() => [
+              createVNode(unref(RouterView))
+            ]),
+            _: 1
+          }))
+        ]),
+        _: 1
+      }, 8, ["application"]);
+    };
+  }
+};
+var App = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "app.vue"]]);
+
+export { App as default };

package/es/application/application.mjs

@@ -0,0 +1,312 @@
+import { createApp, reactive, h } from 'vue';
+import { createWebHistory, createMemoryHistory, createWebHashHistory, createRouter } from 'vue-router';
+import { EventDispatcher, HttpRequest } from '@ctzy-web-client/support';
+import { IocContainer, InstantiationService, SERVICE_INFO } from '@ctzy-web-client/ioc';
+import { SimpleOrm, DataModelAdapter } from '@ctzy-web-client/data-model';
+import { MicroApplication } from './MicroApplication.mjs';
+import '../utils/index.mjs';
+import App from './app.mjs';
+import '../interceptors/index.mjs';
+import '../ioc/index.mjs';
+import { ReactiveInstantiationService } from '../ioc/ReactiveInstantiationService.mjs';
+import { RequestInterceptors } from '../interceptors/RequestInterceptors.mjs';
+import { RouterInterceptors } from '../interceptors/RouterInterceptors.mjs';
+import { pageDataParser } from '../utils/pageDataParser.mjs';
+
+class Application extends EventDispatcher {
+  constructor(appName, options) {
+    super();
+    this.appName = appName;
+    this.options = options || {};
+    this._app = null;
+    this._router = null;
+    this._history = null;
+    this._iocContainer = new 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(InstantiationService);
+  }
+  createInstance(Clazz, options) {
+    return this.getInstantiationService().createInstance(Clazz, options);
+  }
+  _initIocContainer() {
+    this._iocContainer.setInstantiationService(ReactiveInstantiationService);
+    this._iocContainer.registerService(RequestInterceptors, RequestInterceptors, {
+      overwrite: true
+    });
+    this._iocContainer.registerService(RouterInterceptors, RouterInterceptors, {
+      overwrite: true
+    });
+    this._iocContainer.registerService(HttpRequest, HttpRequest, {
+      overwrite: true,
+      args: [this.options.request || {}]
+    });
+    this._iocContainer.registerService(SimpleOrm, SimpleOrm, {
+      overwrite: false
+    });
+    this._iocContainer.registerService(DataModelAdapter, 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[SERVICE_INFO];
+      this._iocContainer.registerService(serviceOptions.value, Service, serviceOptions);
+    }
+    Reflect.deleteProperty(this.global, "__DELAY_REGISTER_SERVICES__");
+  }
+  _setRequestInterceptors() {
+    const httpRequest = this._iocContainer.getService(HttpRequest);
+    const requestInterceptors = this._iocContainer.getService(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);
+    this._router.beforeEach(routerInterceptors.beforeEach.bind(routerInterceptors));
+    this._router.beforeResolve(routerInterceptors.beforeResolve.bind(routerInterceptors));
+    this._router.afterEach(routerInterceptors.afterEach.bind(routerInterceptors));
+  }
+  _initVue() {
+    this._app = createApp({
+      setup: () => {
+        const applicaiton = reactive(this);
+        return () => h(this.options.app || App, {
+          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 = createWebHashHistory(base);
+        break;
+      case "memory":
+        history = createMemoryHistory(base);
+        break;
+      default:
+        history = createWebHistory(base);
+    }
+    this._history = history;
+    this._router = createRouter({
+      history,
+      routes: []
+    });
+    this._setRouteInterceptors();
+    this._app.use(this._router);
+  }
+  async _resolveRoutes() {
+    let pageDefines = await 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(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();
+  }
+}
+
+export { Application };

package/es/application/index.mjs

@@ -0,0 +1,11 @@
+import { withInstall } from 'element-plus/es/utils/vue/install';
+import Application from './application2.mjs';
+import MicroApplication from './micro-application.mjs';
+export { Application } from './Application.mjs';
+
+const BwaApplication = withInstall(Application, {
+  MicroApplication
+});
+const BwaMicroApplication = withInstall(MicroApplication);
+
+export { BwaApplication, BwaMicroApplication, BwaApplication as default };

package/es/application/micro-application.mjs

@@ -0,0 +1,59 @@
+import { defineComponent, ref, computed, onMounted, onBeforeUnmount, withAsyncContext, setBlockTracking, createElementVNode, normalizeClass, unref } from 'vue';
+import { applicationKey } from '@ctzy-web-client/tokens';
+import '../hooks/index.mjs';
+import _export_sfc from '../_virtual/_plugin-vue_export-helper.mjs';
+import { useNamespace } from '../hooks/use-namespace/index.mjs';
+import { useGlobalConfig } from '../hooks/use-global-config/index.mjs';
+
+const __default__ = 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 = useNamespace("application");
+    const application = useGlobalConfig(applicationKey);
+    const el = ref(null);
+    const microApplication = computed(
+      () => application.value.getMicroApplication(props.name) || application.value.createMicroApplication({
+        name: props.name,
+        entry: props.entry,
+        extendOptions: props.extendOptions
+      })
+    );
+    const mountApplicationPromise = microApplication.value.mountApplication();
+    onMounted(() => {
+      el.value.appendChild(microApplication.value.container);
+    });
+    onBeforeUnmount(() => {
+      el.value.removeChild(microApplication.value.container);
+      microApplication.value.unmountApplication();
+    });
+    ;
+    [__temp, __restore] = withAsyncContext(() => mountApplicationPromise), await __temp, __restore();
+    return (_ctx, _cache) => {
+      return _cache[0] || (setBlockTracking(-1), _cache[0] = createElementVNode("div", {
+        ref_key: "el",
+        ref: el,
+        class: normalizeClass(unref(ns).b("mcrio"))
+      }, null, 2), setBlockTracking(1), _cache[0]);
+    };
+  }
+});
+var MicroApplication = /* @__PURE__ */ _export_sfc(_sfc_main, [["__file", "micro-application.vue"]]);
+
+export { MicroApplication as default };

package/es/constants/index.mjs

@@ -0,0 +1 @@
+

package/es/hooks/index.mjs

@@ -0,0 +1,11 @@
+export { provideGlobalConfig, useGlobalConfig } from './use-global-config/index.mjs';
+export { defaultNamespace, useNamespace } from './use-namespace/index.mjs';
+export { useDataForm } from './use-data-form/index.mjs';
+export { useDataTable } from './use-data-table/index.mjs';
+export { useService } from './use-service/index.mjs';
+export { useValue } from './use-value/index.mjs';
+import './use-keydown/index.mjs';
+export { useEventDispatcher } from './use-event-dispatcher/index.mjs';
+export { useDataTablePage } from './use-data-table-page/index.mjs';
+export { useKeydown } from './use-keydown/use-keydown.mjs';
+export { useSaveKeydown } from './use-keydown/use-save-keydown.mjs';

package/es/hooks/use-data-form/index.mjs

@@ -0,0 +1,18 @@
+import { ref } from 'vue';
+import { DataForm } from '@ctzy-web-client/data-model';
+import { applicationKey } from '@ctzy-web-client/tokens';
+import { useGlobalConfig } from '../use-global-config/index.mjs';
+
+const useDataForm = (model, options = {}) => {
+  const application = useGlobalConfig(applicationKey);
+  const dataForm = ref(application.value.createInstance(DataForm, {
+    args: [{
+      model,
+      ...options
+    }]
+  }));
+  dataForm.value.init();
+  return dataForm;
+};
+
+export { useDataForm };

package/es/hooks/use-data-table/index.mjs

@@ -0,0 +1,18 @@
+import { ref } from 'vue';
+import { DataTable } from '@ctzy-web-client/data-model';
+import { applicationKey } from '@ctzy-web-client/tokens';
+import { useGlobalConfig } from '../use-global-config/index.mjs';
+
+const useDataTable = (model, options = {}) => {
+  const application = useGlobalConfig(applicationKey);
+  const dataTable = ref(application.value.createInstance(DataTable, {
+    args: [{
+      model,
+      ...options
+    }]
+  }));
+  dataTable.value.init();
+  return dataTable;
+};
+
+export { useDataTable };

package/es/hooks/use-data-table-page/index.mjs

@@ -0,0 +1,47 @@
+import { unref } from 'vue';
+import { useRouter, useRoute } from 'vue-router';
+import { useEventDispatcher } from '../use-event-dispatcher/index.mjs';
+
+const useDataTablePage = (dataTable, options = {}) => {
+  options = {
+    ...options
+  };
+  options.currentPage = options.currentPage || "currentPage";
+  options.pageSize = options.pageSize || "pageSize";
+  const router = useRouter();
+  const route = useRoute();
+  let {
+    currentPage = unref(dataTable).pageNum,
+    pageSize = unref(dataTable).pageSize
+  } = unref(route).query;
+  currentPage = parseInt(currentPage);
+  pageSize = parseInt(pageSize);
+  if (isNaN(currentPage)) {
+    currentPage = unref(dataTable).pageNum;
+  }
+  if (isNaN(pageSize)) {
+    pageSize = unref(dataTable).pageSize;
+  }
+  unref(dataTable).pageNum = currentPage;
+  unref(dataTable).pageSize = pageSize;
+  useEventDispatcher(dataTable, "current-page-change", (currentPage2) => {
+    const query = unref(router.currentRoute).query;
+    router.replace({
+      query: {
+        ...query,
+        currentPage: currentPage2
+      }
+    });
+  });
+  useEventDispatcher(dataTable, "page-size-change", (pageSize2) => {
+    const query = unref(router.currentRoute).query;
+    router.replace({
+      query: {
+        ...query,
+        pageSize: pageSize2
+      }
+    });
+  });
+};
+
+export { useDataTablePage };

package/es/hooks/use-event-dispatcher/index.mjs

@@ -0,0 +1,14 @@
+import { onMounted, unref, onUnmounted } from 'vue';
+
+const useEventDispatcher = (eventDispatcher, eventName, handler) => {
+  onMounted(() => {
+    unref(eventDispatcher).on(eventName, handler);
+  });
+  const off = () => {
+    unref(eventDispatcher).off(eventName, handler);
+  };
+  onUnmounted(off);
+  return off;
+};
+
+export { useEventDispatcher };

package/es/hooks/use-global-config/index.mjs

@@ -0,0 +1,47 @@
+import { ref, getCurrentInstance, inject, computed, provide, unref } from 'vue';
+import { configProviderContextKey } from '@ctzy-web-client/tokens';
+
+const globalConfig = ref();
+function useGlobalConfig(key, defaultValue) {
+  const config = getCurrentInstance() ? inject(configProviderContextKey, globalConfig) : globalConfig;
+  if (key) {
+    return computed(() => {
+      var _a, _b;
+      return (_b = (_a = config.value) == null ? void 0 : _a[key]) != null ? _b : defaultValue;
+    });
+  } else {
+    return config;
+  }
+}
+const provideGlobalConfig = (config, app, global = false) => {
+  var _a;
+  const inSetup = !!getCurrentInstance();
+  const oldConfig = inSetup ? useGlobalConfig() : void 0;
+  const provideFn = (_a = app == null ? void 0 : app.provide) != null ? _a : inSetup ? provide : void 0;
+  if (!provideFn) {
+    console.warn("provideGlobalConfig", "provideGlobalConfig() can only be used inside setup().");
+    return;
+  }
+  const context = computed(() => {
+    const cfg = unref(config);
+    if (!(oldConfig == null ? void 0 : oldConfig.value))
+      return cfg;
+    return mergeConfig(oldConfig.value, cfg);
+  });
+  provideFn(configProviderContextKey, context);
+  if (global || !globalConfig.value) {
+    globalConfig.value = context.value;
+  }
+  return context;
+};
+const mergeConfig = (a, b) => {
+  var _a;
+  const keys = [.../* @__PURE__ */ new Set([...Reflect.ownKeys(a), ...Reflect.ownKeys(b)])];
+  const obj = {};
+  for (const key of keys) {
+    obj[key] = (_a = b[key]) != null ? _a : a[key];
+  }
+  return obj;
+};
+
+export { provideGlobalConfig, useGlobalConfig };

package/es/hooks/use-keydown/index.mjs

@@ -0,0 +1,2 @@
+export { useKeydown } from './use-keydown.mjs';
+export { useSaveKeydown } from './use-save-keydown.mjs';