@ibiz-template/vue3-util 0.6.0 → 0.6.1-alpha.2

package/lib/util/overlay-view-util/overlay-view-util.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+var vue = require('vue');
+
+"use strict";
+function createOverlayView(props) {
+  return (modal) => {
+    const viewShell = vue.resolveComponent("IBizViewShell");
+    return vue.h(viewShell, {
+      ...props,
+      modal
+    });
+  };
+}
+async function openViewModal(props, opts) {
+  const overlay = ibiz.overlay.createModal(
+    createOverlayView(props),
+    void 0,
+    opts
+  );
+  overlay.present();
+  const result = await overlay.onWillDismiss();
+  return result || { ok: false };
+}
+async function openViewFloatWindow(props, opts) {
+  const overlay = ibiz.overlay.createFloatWindow(
+    createOverlayView(props),
+    void 0,
+    opts
+  );
+  overlay.present();
+  const result = await overlay.onWillDismiss();
+  return result || { ok: false };
+}
+async function openViewDrawer(props, opts) {
+  const overlay = ibiz.overlay.createDrawer(
+    createOverlayView(props),
+    void 0,
+    opts
+  );
+  await overlay.present();
+  const result = await overlay.onWillDismiss();
+  return result || { ok: false };
+}
+async function openViewPopover(event, props, opts) {
+  const overlay = ibiz.overlay.createPopover(
+    createOverlayView(props),
+    void 0,
+    opts
+  );
+  overlay.present(event.target);
+  const result = await overlay.onWillDismiss();
+  return result || { ok: false };
+}
+const PlacementMap = {
+  DRAWER_LEFT: "left",
+  DRAWER_RIGHT: "right",
+  DRAWER_TOP: "top",
+  DRAWER_BOTTOM: "bottom"
+};
+function getDrawerPlacement(openMode) {
+  return PlacementMap[openMode] || "right";
+}
+
+exports.createOverlayView = createOverlayView;
+exports.getDrawerPlacement = getDrawerPlacement;
+exports.openViewDrawer = openViewDrawer;
+exports.openViewFloatWindow = openViewFloatWindow;
+exports.openViewModal = openViewModal;
+exports.openViewPopover = openViewPopover;

package/lib/util/render/render.cjs

@@ -0,0 +1,22 @@
+'use strict';
+
+var ramda = require('ramda');
+
+"use strict";
+function renderString(value) {
+  if (ramda.isNil(value)) {
+    return "";
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    const str = value.toString();
+    return str;
+  } catch (error) {
+    ibiz.log.error(value, "\u8F6C\u6362\u6210\u5B57\u7B26\u4E32\u5931\u8D25", error);
+  }
+  return "";
+}
+
+exports.renderString = renderString;

package/lib/util/route/route-listener.cjs

@@ -0,0 +1,75 @@
+'use strict';
+
+var vue = require('vue');
+
+"use strict";
+class RouteListener {
+  constructor(route, wait) {
+    /**
+     * 回调集合
+     *
+     * @memberof RouteListener
+     */
+    this.callbacks = [];
+    /**
+     * 计时器集合
+     *
+     * @private
+     * @type {any[]}
+     * @memberof RouteListener
+     */
+    this.timers = [];
+    /**
+     * 等待路由响应时间
+     *
+     * @private
+     * @type {number}
+     * @memberof RouteListener
+     */
+    this.wait = 500;
+    if (wait) {
+      this.wait = wait;
+    }
+    vue.watch(
+      () => route.path,
+      (newVal, oldVal) => {
+        if (newVal !== oldVal) {
+          if (this.callbacks.length) {
+            for (let index = 0; index < this.callbacks.length; index++) {
+              const fn = this.callbacks[index];
+              fn();
+            }
+          }
+          this.callbacks = [];
+          if (this.timers.length) {
+            for (let index = 0; index < this.timers.length; index++) {
+              const timer = this.timers[index];
+              clearTimeout(timer);
+            }
+          }
+          this.timers = [];
+        }
+      }
+    );
+  }
+  /**
+   * 下一次路由变更后执行回调，只执行一次
+   *
+   * @param {ChangeCallback} callback
+   * @memberof RouteListener
+   */
+  nextChange(callback) {
+    if (callback) {
+      this.timers.push(
+        setTimeout(() => {
+          callback();
+          const index = this.callbacks.findIndex((item) => item === callback);
+          this.callbacks.splice(index, 1);
+        }, this.wait)
+      );
+      this.callbacks.push(callback);
+    }
+  }
+}
+
+exports.RouteListener = RouteListener;

package/lib/util/route/route.cjs

@@ -0,0 +1,302 @@
+'use strict';
+
+var qxUtil = require('qx-util');
+var core = require('@ibiz-template/core');
+var qs = require('qs');
+var vueRouter = require('vue-router');
+var vue = require('vue');
+var runtime = require('@ibiz-template/runtime');
+
+"use strict";
+function route2routePath(route, isRouteModal = false) {
+  const depth = route.matched.length;
+  let path = route.path;
+  if (isRouteModal) {
+    path = path.replace(new RegExp("/".concat(runtime.RouteConst.ROUTE_MODAL_TAG), "g"), "");
+  }
+  const items = path.split("/");
+  const pathNodes = [];
+  for (let index = 1; index <= depth; index++) {
+    const viewName = items[index * 2];
+    const paramsStr = route.params["params".concat(index)];
+    let params;
+    let context;
+    let srfnav;
+    if (!paramsStr || paramsStr === ibiz.env.routePlaceholder) {
+      params = void 0;
+    } else {
+      params = qs.parse(paramsStr, {
+        strictNullHandling: true,
+        delimiter: ";"
+      });
+    }
+    if (params) {
+      if (index === 1) {
+        context = params;
+        params = void 0;
+      } else {
+        if (params.srfnavctx) {
+          context = JSON.parse(decodeURIComponent(params.srfnavctx));
+          delete params.srfnavctx;
+        }
+        if (params.srfnav) {
+          srfnav = params.srfnav;
+          delete params.srfnav;
+        }
+      }
+    }
+    pathNodes.push({ viewName, context, params, srfnav });
+  }
+  let appContext;
+  if (route.params.appContext && route.params.appContext !== ibiz.env.routePlaceholder) {
+    appContext = qs.parse(route.params.appContext, {
+      strictNullHandling: true,
+      delimiter: ";"
+    });
+  }
+  return { appContext, pathNodes };
+}
+function routePath2string(routePath) {
+  let pathStr = "";
+  if (routePath.appContext) {
+    pathStr += "/".concat(qs.stringify(routePath.appContext, {
+      delimiter: ";",
+      strictNullHandling: true
+    }));
+  } else {
+    pathStr += "/".concat(ibiz.env.routePlaceholder);
+  }
+  routePath.pathNodes.forEach((pathNode, index) => {
+    pathStr += "/".concat(pathNode.viewName, "/");
+    let routeParams = {};
+    if (index === 0) {
+      if (qxUtil.notNilEmpty(pathNode.context)) {
+        routeParams = pathNode.context;
+      }
+    } else {
+      routeParams = qxUtil.notNilEmpty(pathNode.params) ? pathNode.params : {};
+      if (qxUtil.notNilEmpty(pathNode.context)) {
+        const objStr = JSON.stringify(pathNode.context);
+        if (objStr !== "{}") {
+          routeParams.srfnavctx = encodeURIComponent(objStr);
+        }
+      }
+      if (pathNode.srfnav) {
+        routeParams.srfnav = pathNode.srfnav;
+      }
+    }
+    const paramsStr = qs.stringify(routeParams, {
+      delimiter: ";",
+      strictNullHandling: true,
+      skipNulls: true
+    });
+    if (qxUtil.notNilEmpty(paramsStr)) {
+      pathStr += paramsStr;
+    } else {
+      pathStr += ibiz.env.routePlaceholder;
+    }
+  });
+  return pathStr;
+}
+function getOwnRouteContext(context) {
+  const ownContext = context.getOwnContext();
+  const excludeKeys = [
+    "srfsessionid",
+    "srfappid",
+    "currentSrfNav",
+    "toRouteDepth"
+  ];
+  Object.keys(ownContext).forEach((key) => {
+    if (excludeKeys.includes(key)) {
+      delete ownContext[key];
+    }
+  });
+  return ownContext;
+}
+const excludeViewTypes = [
+  runtime.ViewType.DE_GRID_VIEW,
+  runtime.ViewType.DE_GRID_EXP_VIEW,
+  runtime.ViewType.DE_LIST_VIEW,
+  runtime.ViewType.DE_LIST_EXP_VIEW,
+  runtime.ViewType.DE_DATA_VIEW,
+  runtime.ViewType.DE_DATAVIEW_EXP_VIEW,
+  runtime.ViewType.DE_CALENDAR_VIEW,
+  runtime.ViewType.DE_CALENDAR_EXP_VIEW,
+  runtime.ViewType.DE_CHART_VIEW,
+  runtime.ViewType.DE_CHART_EXP_VIEW,
+  runtime.ViewType.DE_KANBAN_VIEW
+];
+async function calcResRoutePath(routePath, context, appDataEntityId, appId) {
+  if (!appDataEntityId) {
+    routePath.pathNodes[0].context = void 0;
+  } else {
+    const entity = await ibiz.hub.getAppDataEntity(appDataEntityId, appId);
+    let match = runtime.getMatchResPath(context, entity);
+    if (!match) {
+      match = { path: "", keys: [entity.codeName.toLowerCase()] };
+    }
+    if (match) {
+      const currentContext = routePath.pathNodes[1].context;
+      const resContext = {};
+      match.keys.forEach((key) => {
+        if (context && Object.prototype.hasOwnProperty.call(context, key)) {
+          resContext[key] = context[key];
+          if (currentContext) {
+            delete currentContext[key];
+          }
+        }
+      });
+      routePath.pathNodes[0].context = resContext;
+    }
+  }
+}
+async function generateRoutePath(appView, route, context, params) {
+  const routePath = route2routePath(route);
+  let depth = context.srfdefaulttoroutedepth || 2;
+  if (context.toRouteDepth) {
+    depth = context.toRouteDepth;
+    context.toRouteDepth = void 0;
+  } else if (ibiz.env.isMob) {
+    routePath.pathNodes[0] = {
+      viewName: "home"
+    };
+  }
+  routePath.pathNodes.splice(depth - 1, routePath.pathNodes.length - depth + 1);
+  if (context.currentSrfNav) {
+    const currentNode = routePath.pathNodes[routePath.pathNodes.length - 1];
+    currentNode.params = currentNode.params || {};
+    currentNode.srfnav = context.currentSrfNav;
+    context.currentSrfNav = void 0;
+  }
+  if (route.fullPath.startsWith("/appredirectview")) {
+    if (params == null ? void 0 : params.srfindexname) {
+      routePath.pathNodes[0].viewName = params.srfindexname;
+      delete params.srfindexname;
+    } else {
+      routePath.pathNodes[0].viewName = "index";
+    }
+  }
+  routePath.pathNodes.push({
+    viewName: appView.codeName.toLowerCase(),
+    context: getOwnRouteContext(context),
+    params
+  });
+  if (depth === 2) {
+    await calcResRoutePath(
+      routePath,
+      context,
+      appView.appDataEntityId,
+      appView.appId
+    );
+    if (excludeViewTypes.includes(appView.viewType)) {
+      const deName = runtime.calcDeCodeNameById(appView.appDataEntityId);
+      delete routePath.pathNodes[0].context[deName];
+    }
+  }
+  return { path: routePath2string(routePath) };
+}
+async function generateRoutePathByModal(appView, route, context, params) {
+  const routePath = route2routePath(route);
+  const findIndex = routePath.pathNodes.findIndex(
+    (item) => item.viewName === runtime.RouteConst.ROUTE_MODAL_TAG
+  );
+  if (findIndex !== -1) {
+    routePath.pathNodes = routePath.pathNodes.slice(0, findIndex);
+  }
+  if (context.currentSrfNav) {
+    const currentNode = routePath.pathNodes[routePath.pathNodes.length - 1];
+    currentNode.params = currentNode.params || {};
+    currentNode.srfnav = context.currentSrfNav;
+    context.currentSrfNav = void 0;
+  }
+  routePath.pathNodes.push({
+    viewName: "".concat(runtime.RouteConst.ROUTE_MODAL_TAG, "/").concat(appView.codeName.toLowerCase()),
+    context: getOwnRouteContext(context),
+    params
+  });
+  return { path: routePath2string(routePath) };
+}
+async function parseRouteViewData(route, depth, isRouteModal = false) {
+  var _a;
+  const routePath = route2routePath(route, isRouteModal);
+  let viewCodeName = routePath.pathNodes[depth - 1].viewName;
+  if (!viewCodeName) {
+    throw new core.RuntimeError("\u7B2C".concat(depth, "\u7EA7\u8DEF\u7531\u4E0D\u5B58\u5728\u89C6\u56FE\u6807\u8BC6"));
+  }
+  if (viewCodeName === runtime.RouteConst.ROUTE_MODAL_TAG) {
+    viewCodeName = routePath.pathNodes[depth].viewName;
+  }
+  if (viewCodeName === "index") {
+    viewCodeName = ibiz.hub.defaultAppIndexViewName;
+  }
+  const viewModel = await ibiz.hub.getAppView(viewCodeName);
+  if (!viewModel) {
+    throw new core.RuntimeError("\u627E\u4E0D\u5230\u89C6\u56FE".concat(viewCodeName));
+  }
+  const context = {};
+  if ((_a = ibiz.appData) == null ? void 0 : _a.context) {
+    Object.assign(context, ibiz.appData.context);
+  }
+  if (routePath.appContext) {
+    Object.assign(context, routePath.appContext);
+  }
+  if (depth !== 1) {
+    for (let index = 0; index < depth; index++) {
+      const pathNode = routePath.pathNodes[index];
+      if (qxUtil.notNilEmpty(pathNode.context)) {
+        Object.assign(context, pathNode.context);
+      }
+    }
+  }
+  const { params, srfnav } = routePath.pathNodes[depth - 1];
+  return {
+    viewModel,
+    context,
+    params,
+    srfnav
+  };
+}
+function getNestedRoutePath(route, depth, noSrfNav = true) {
+  if (route.matched.length < depth) {
+    return "";
+  }
+  if (route.matched.length === depth && route.name) {
+    return route.path;
+  }
+  const routePath = route2routePath(route);
+  if (routePath.pathNodes.length < depth) {
+    return route.path;
+  }
+  if (routePath.pathNodes.length > depth) {
+    routePath.pathNodes = routePath.pathNodes.slice(0, depth);
+  }
+  if (noSrfNav) {
+    delete routePath.pathNodes[depth - 1].srfnav;
+  }
+  return routePath2string(routePath);
+}
+function onRouteChange(callback, depth) {
+  const route = vueRouter.useRoute();
+  if (!route) {
+    throw new core.RuntimeError("\u65E0\u6CD5\u6B63\u786E\u83B7\u53D6route,\u53EF\u80FD\u662F\u4F9D\u8D56\u95EE\u9898");
+  }
+  vue.watch(
+    () => route == null ? void 0 : route.path,
+    () => {
+      const currentKey = getNestedRoutePath(route, depth);
+      callback({ currentKey, fullPath: route.fullPath });
+    },
+    { immediate: true }
+  );
+}
+
+exports.calcResRoutePath = calcResRoutePath;
+exports.excludeViewTypes = excludeViewTypes;
+exports.generateRoutePath = generateRoutePath;
+exports.generateRoutePathByModal = generateRoutePathByModal;
+exports.getNestedRoutePath = getNestedRoutePath;
+exports.getOwnRouteContext = getOwnRouteContext;
+exports.onRouteChange = onRouteChange;
+exports.parseRouteViewData = parseRouteViewData;
+exports.route2routePath = route2routePath;
+exports.routePath2string = routePath2string;

package/lib/util/router-callback/router-callback-item.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+"use strict";
+class RouterCallbackItem {
+  constructor(from, to) {
+    this.from = from;
+    this.to = to;
+    /**
+     * 是否已经有打开的视图认领此回调，如果在一定时间内没有被认领，则会被清除
+     *
+     * @author chitanda
+     * @date 2023-07-13 21:07:35
+     */
+    this.isActivated = false;
+    ibiz.log.debug("openRouter: ", from, to);
+  }
+  /**
+   * 等待视图关闭
+   *
+   * @author chitanda
+   * @date 2023-07-13 21:07:34
+   * @return {*}  {Promise<IModalData>}
+   */
+  onWillDismiss() {
+    if (!this.promise) {
+      this.promise = new Promise((resolve) => {
+        this.resolve = resolve;
+      });
+    }
+    return this.promise.then((modal) => {
+      ibiz.log.debug("onWillDismiss: ", this.from, this.to, modal);
+      return modal;
+    });
+  }
+  /**
+   * 关闭视图
+   *
+   * @author chitanda
+   * @date 2023-07-13 21:07:06
+   * @param {IModalData} modal
+   */
+  close(modal) {
+    ibiz.log.debug("closeRouter: ", this.from, this.to, modal);
+    if (this.resolve) {
+      this.resolve(modal);
+      this.resolve = void 0;
+    }
+  }
+  /**
+   * 激活回调
+   *
+   * @author chitanda
+   * @date 2023-07-13 21:07:29
+   */
+  active() {
+    ibiz.log.debug("activeRouter: ", this.from, this.to);
+    this.isActivated = true;
+  }
+  /**
+   * 销毁回调
+   *
+   * @author chitanda
+   * @date 2023-07-13 21:07:21
+   */
+  destroy() {
+    ibiz.log.debug("destroyRouter: ", this.from, this.to);
+    if (this.resolve) {
+      this.resolve({ ok: false });
+      this.resolve = void 0;
+    }
+  }
+}
+
+exports.RouterCallbackItem = RouterCallbackItem;

package/{src/util/router-callback/router-callback.ts → lib/util/router-callback/router-callback.cjs}

@@ -1,26 +1,20 @@
-import { IModalData } from '@ibiz-template/runtime';
-import { Router } from 'vue-router';
-import { RouterCallbackItem } from './router-callback-item';
+'use strict';
 
-/**
- * 路由打开视图回调，连通上级视图的关闭
- *
- * @author chitanda
- * @date 2023-07-13 20:07:20
- * @export
- * @class RouterCallback
- */
-export class RouterCallback {
-  /**
-   * 回调实例
-   *
-   * @author chitanda
-   * @date 2023-07-13 20:07:12
-   * @protected
-   * @type {Map<string, RouterCallbackItem>}
-   */
-  protected map: Map<string, RouterCallbackItem> = new Map();
+var routerCallbackItem = require('./router-callback-item.cjs');
 
+"use strict";
+class RouterCallback {
+  constructor() {
+    /**
+     * 回调实例
+     *
+     * @author chitanda
+     * @date 2023-07-13 20:07:12
+     * @protected
+     * @type {Map<string, RouterCallbackItem>}
+     */
+    this.map = /* @__PURE__ */ new Map();
+  }
   /**
    * 打开视图
    *
@@ -30,20 +24,23 @@ export class RouterCallback {
    * @param {string} path
    * @return {*}  {Promise<IModalData>}
    */
-  async open(router: Router, path: string): Promise<IModalData> {
+  async open(router, path, modalOptions = {}) {
     const from = router.currentRoute.value.fullPath;
-    router.push({ path });
+    if (modalOptions.replace) {
+      router.replace({ path });
+    } else {
+      router.push({ path });
+    }
     const to = path;
     if (this.map.has(to)) {
-      const item = this.map.get(to)!;
-      return item.onWillDismiss();
+      const item2 = this.map.get(to);
+      return item2.onWillDismiss();
     }
-    const item = new RouterCallbackItem(from, to);
+    const item = new routerCallbackItem.RouterCallbackItem(from, to);
     this.map.set(to, item);
     this.scheduledDestruction(item);
     return item.onWillDismiss();
   }
-
   /**
    * 关闭视图回调
    *
@@ -52,14 +49,13 @@ export class RouterCallback {
    * @param {string} toFullPath
    * @param {IModalData} modal
    */
-  close(toFullPath: string, modal: IModalData): void {
+  close(toFullPath, modal) {
     const item = this.map.get(toFullPath);
     if (item) {
       item.close(modal);
       this.map.delete(toFullPath);
     }
   }
-
   /**
    * 激活回调
    *
@@ -67,15 +63,14 @@ export class RouterCallback {
    * @date 2023-07-13 21:07:03
    * @param {string} toFullPath
    */
-  active(toFullPath: string): void {
+  active(toFullPath) {
     const item = this.map.get(toFullPath);
     if (item) {
       window.clearTimeout(item.timeout);
-      item.timeout = undefined;
+      item.timeout = void 0;
       item.active();
     }
   }
-
   /**
    * 一分钟内未激活的视图回调会被清除
    *
@@ -84,14 +79,15 @@ export class RouterCallback {
    * @protected
    * @param {RouterCallbackItem} item
    */
-  protected scheduledDestruction(item: RouterCallbackItem): void {
+  scheduledDestruction(item) {
     item.timeout = window.setTimeout(() => {
-      item.timeout = undefined;
+      item.timeout = void 0;
       item.destroy();
       this.map.delete(item.to);
-    }, 10 * 1000);
+    }, 10 * 1e3);
   }
 }
+const routerCallback = new RouterCallback();
 
-// 路由打开视图回调，连通上级视图的关闭工具类
-export const routerCallback = new RouterCallback();
+exports.RouterCallback = RouterCallback;
+exports.routerCallback = routerCallback;

package/lib/util/store/app-store/app-store.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var pinia = require('pinia');
+var vue = require('vue');
+
+"use strict";
+const useAppStore = pinia.defineStore("appStore", () => {
+  const appStore = vue.reactive({});
+  return { appStore };
+});
+
+exports.useAppStore = useAppStore;

package/lib/util/store/index.cjs

@@ -0,0 +1,12 @@
+'use strict';
+
+var pinia = require('pinia');
+var appStore = require('./app-store/app-store.cjs');
+var uiStore = require('./ui-store/ui-store.cjs');
+
+"use strict";
+const piniaInstance = pinia.createPinia();
+
+exports.useAppStore = appStore.useAppStore;
+exports.useUIStore = uiStore.useUIStore;
+exports.piniaInstance = piniaInstance;