@fecp/mobile-designer 1.0.8 → 1.0.10

package/lib/packages/mobile/src/utils/eventFlow/eventFlowHandler.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const eventFlowParser = require("../eventFlowParser.js");
+async function executeEventFlow(params) {
+  const {
+    eventFlow,
+    fields = [],
+    instance = null,
+    localConfig = {},
+    components = {},
+    onSuccess,
+    onError,
+    row,
+    item,
+    metadata
+  } = params;
+  if (!eventFlow) {
+    return;
+  }
+  try {
+    const parser = eventFlowParser.createEventFlowParser({
+      eventFlow,
+      fields,
+      data: row,
+      instance,
+      localConfig,
+      components,
+      metadata
+    });
+    const result = await parser.start();
+    console.log("事件流执行完成:", result);
+    parser.destroy();
+    if (onSuccess) {
+      onSuccess(result, row, item);
+    }
+    return result;
+  } catch (error) {
+    console.error("事件流执行失败:", error);
+    if (onError) {
+      onError(error, row, item);
+    }
+    throw error;
+  }
+}
+function createEventFlowHandler(options = {}) {
+  const {
+    fields = [],
+    instance = null,
+    onSuccess,
+    onError,
+    localConfig = {},
+    components = {},
+    metadata = {}
+  } = options;
+  return async function handleEvent(row, item, eventConfig) {
+    if (eventConfig && eventConfig.eventFlow) {
+      return await executeEventFlow({
+        eventFlow: eventConfig.eventFlow,
+        fields,
+        instance,
+        localConfig,
+        components,
+        onSuccess,
+        onError,
+        row,
+        item,
+        metadata: { ...metadata, item }
+      });
+    }
+  };
+}
+function getEventHandlers(item, row, eventHandler, eventConfigs) {
+  const handlers = {};
+  if (!eventConfigs) {
+    return handlers;
+  }
+  eventConfigs.forEach((eventConfig) => {
+    if (!eventConfig.name) return;
+    const eventName = eventConfig.name.toLowerCase();
+    handlers[eventName] = () => eventHandler(row, item, eventConfig);
+  });
+  return handlers;
+}
+function useEventFlow(options = {}) {
+  const handleEvent = createEventFlowHandler(options);
+  return {
+    handleEvent,
+    getEventHandlers: (item, row, eventConfig) => getEventHandlers(item, row, handleEvent, eventConfig)
+  };
+}
+exports.createEventFlowHandler = createEventFlowHandler;
+exports.executeEventFlow = executeEventFlow;
+exports.getEventHandlers = getEventHandlers;
+exports.useEventFlow = useEventFlow;

package/lib/packages/mobile/src/utils/eventFlowParser.js

@@ -0,0 +1,395 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const parseFilterConfig = require("./parseFilterConfig.js");
+const actionHandlers = require("./eventFlow/actionHandlers.js");
+const elementPlus = require("element-plus");
+const NodeType = {
+  START: "start",
+  END: "end",
+  EXCLUSIVE: "exclusive",
+  // 独占网关
+  CONDITION: "condition",
+  // 条件分支
+  APPROVAL: "approval"
+  // 动作/审批节点
+};
+class EventFlowParser {
+  constructor(options = {}) {
+    this.options = options;
+    this.eventFlow = options.eventFlow || null;
+    this.fields = options.fields || [];
+    this.data = options.data || {};
+    this.components = options.components || {};
+    this.currentNode = null;
+    this.isPaused = false;
+    this.pausePromise = null;
+    this.pauseResolve = null;
+    this.pauseReject = null;
+    this.executionPath = [];
+    this.context = {
+      variables: {},
+      // 运行时变量
+      results: []
+      // 每个节点的执行结果
+    };
+    this.metadata = options.metadata || {};
+    this.actionHandlers = {
+      ...actionHandlers.defaultActionHandlers,
+      ...options.customActionHandlers
+      // 允许自定义动作处理器
+    };
+    this.bindActionHandlers();
+  }
+  /**
+   * 启动事件流
+   * @param {Object} data - 数据对象
+   * @returns {Promise<Object>} 执行结果
+   */
+  async start(data = null) {
+    if (data) {
+      this.data = data;
+    }
+    if (!this.eventFlow) {
+      throw new Error("事件流配置未设置");
+    }
+    this.isPaused = false;
+    this.pausePromise = null;
+    this.pauseResolve = null;
+    this.pauseReject = null;
+    this.executionPath = [];
+    this.context = {
+      variables: {},
+      results: []
+    };
+    const startNode = this.eventFlow;
+    if (startNode.type !== NodeType.START) {
+      throw new Error("事件流缺少开始节点");
+    }
+    this.currentNode = startNode;
+    return await this.executeCurrentNode();
+  }
+  /**
+   * 继续执行（用于从暂停状态恢复）
+   * @param {*} resumeData - 恢复时传递的数据（例如confirm的结果）
+   * @returns {Promise<Object>}
+   */
+  async resume(resumeData = null) {
+    if (!this.isPaused || !this.pauseResolve) {
+      throw new Error("事件流未处于暂停状态");
+    }
+    this.isPaused = false;
+    this.pauseResolve(resumeData);
+    await this.pausePromise;
+    return await this.executeCurrentNode();
+  }
+  /**
+   * 取消执行（用于取消confirm等操作）
+   * @param {*} reason - 取消原因
+   */
+  cancel(reason = "用户取消") {
+    if (!this.isPaused || !this.pauseReject) {
+      throw new Error("事件流未处于暂停状态");
+    }
+    this.isPaused = false;
+    this.pauseReject(new Error(reason));
+  }
+  /**
+   * 执行当前节点
+   * @returns {Promise<Object>}
+   */
+  async executeCurrentNode() {
+    if (!this.currentNode) {
+      return this.getExecutionResult();
+    }
+    const node = this.currentNode;
+    const nodeResult = {
+      id: node.id,
+      type: node.type,
+      name: node.name,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      success: true,
+      data: null,
+      error: null
+    };
+    try {
+      let nextNode = null;
+      switch (node.type) {
+        case NodeType.START:
+          nextNode = await this.executeStartNode(node);
+          break;
+        case NodeType.END:
+          nextNode = await this.executeEndNode(node);
+          break;
+        case NodeType.EXCLUSIVE:
+          nextNode = await this.executeExclusiveNode(node);
+          break;
+        case NodeType.CONDITION:
+          nextNode = await this.executeConditionNode(node);
+          break;
+        case NodeType.APPROVAL:
+          nextNode = await this.executeApprovalNode(node);
+          break;
+        default:
+          throw new Error(`未知的节点类型: ${node.type}`);
+      }
+      nodeResult.data = this.context.variables[node.id] || null;
+      this.context.results.push(nodeResult);
+      const pathItem = {
+        nodeId: node.id,
+        nodeName: node.name,
+        nodeType: node.type,
+        timestamp: nodeResult.timestamp
+      };
+      pathItem.actionType = node.actionType;
+      pathItem.actionName = node.actionName;
+      pathItem.actionResult = nodeResult.data;
+      this.executionPath.push(pathItem);
+      if (nextNode) {
+        this.currentNode = nextNode;
+        return await this.executeCurrentNode();
+      } else {
+        return this.getExecutionResult();
+      }
+    } catch (error) {
+      nodeResult.success = false;
+      nodeResult.error = error.message;
+      this.context.results.push(nodeResult);
+      throw error;
+    }
+  }
+  /**
+   * 执行开始节点
+   */
+  async executeStartNode(node) {
+    return node.next || null;
+  }
+  /**
+   * 执行结束节点
+   */
+  async executeEndNode(node) {
+    return null;
+  }
+  /**
+   * 执行独占网关
+   * 根据条件选择分支
+   */
+  async executeExclusiveNode(node) {
+    if (!node.branches || node.branches.length === 0) {
+      throw new Error("独占网关没有配置分支");
+    }
+    let matchedBranch = null;
+    let defaultBranch = null;
+    for (const branch of node.branches) {
+      if (branch.def) {
+        defaultBranch = branch;
+        continue;
+      }
+      if (await this.checkBranchCondition(branch)) {
+        matchedBranch = branch;
+        break;
+      }
+    }
+    if (!matchedBranch && defaultBranch) {
+      matchedBranch = defaultBranch;
+    }
+    if (!matchedBranch) {
+      throw new Error("没有满足条件的分支，且没有默认分支");
+    }
+    this.context.variables[node.id] = {
+      selectedBranch: matchedBranch.id,
+      branchName: matchedBranch.name
+    };
+    return matchedBranch.next || node.next || null;
+  }
+  /**
+   * 检查分支条件是否满足
+   */
+  async checkBranchCondition(branch) {
+    if (!branch.conditions) {
+      return false;
+    }
+    if (branch.def && (!branch.conditions.conditions || branch.conditions.conditions.length === 0)) {
+      return true;
+    }
+    return parseFilterConfig.checkFilterMatch(branch.conditions, this.data, this.fields);
+  }
+  /**
+   * 执行条件节点
+   */
+  async executeConditionNode(node) {
+    return node.next || null;
+  }
+  /**
+   * 执行动作/审批节点
+   */
+  async executeApprovalNode(node) {
+    var _a, _b;
+    if (!node.actionType) {
+      throw new Error("动作节点没有配置动作类型");
+    }
+    if ((_a = node.advanced) == null ? void 0 : _a.skipCondition) {
+      const shouldSkip = parseFilterConfig.checkFilterMatch(
+        node.advanced.skipCondition,
+        this.data,
+        this.fields
+      );
+      if (shouldSkip) {
+        this.context.variables[node.id] = { skipped: true, reason: "满足跳过条件" };
+        this.executionPath.push({
+          nodeId: node.id,
+          nodeType: node.type,
+          actionType: node.actionType,
+          actionName: node.actionName,
+          result: {
+            skipped: true,
+            reason: "满足跳过条件"
+          }
+        });
+        return node.next || null;
+      }
+    }
+    const actionResult = await this.executeAction(node);
+    if (actionResult === null) {
+      return null;
+    }
+    this.context.variables[node.id] = {
+      actionType: node.actionType,
+      actionName: node.actionName,
+      result: actionResult
+    };
+    if (actionResult.success === false) {
+      const errorMessage = actionResult.message || "动作执行失败";
+      console.error("[EventFlow] 动作执行失败:", errorMessage);
+      if (actionResult.shouldShowError !== false) {
+        elementPlus.ElMessage.error(errorMessage);
+      }
+      throw new Error(errorMessage);
+    }
+    if ((_b = node.advanced) == null ? void 0 : _b.blockCondition) {
+      const shouldBlock = parseFilterConfig.checkFilterMatch(
+        node.advanced.blockCondition,
+        this.data,
+        this.fields
+      );
+      if (shouldBlock) {
+        console.log("后续动作被阻止条件拦截");
+        this.executionPath.push({
+          nodeId: node.id,
+          nodeType: node.type,
+          actionType: node.actionType,
+          actionName: node.actionName,
+          result: {
+            blocked: true,
+            reason: "后续动作被阻止条件拦截"
+          }
+        });
+        return null;
+      }
+    }
+    return node.next || null;
+  }
+  /**
+   * 执行动作
+   */
+  async executeAction(node) {
+    var _a, _b, _c, _d, _e, _f;
+    const handler = this.actionHandlers[node.actionType];
+    if (!handler) {
+      throw new Error(`未找到动作处理器: ${node.actionType}`);
+    }
+    const context = {
+      parser: this,
+      instance: (_a = this.options) == null ? void 0 : _a.instance,
+      ctx: (_c = (_b = this.options) == null ? void 0 : _b.instance) == null ? void 0 : _c.proxy,
+      customActions: (_d = this.options) == null ? void 0 : _d.customActions,
+      localConfig: (_e = this.options) == null ? void 0 : _e.localConfig,
+      components: this.components,
+      metadata: (_f = this.options) == null ? void 0 : _f.metadata
+    };
+    return await handler(node, this.data, this.fields, context);
+  }
+  /**
+   * 绑定动作处理器的上下文
+   */
+  bindActionHandlers() {
+    for (const actionType in this.actionHandlers) {
+      if (typeof this.actionHandlers[actionType] === "function") {
+        this.actionHandlers[actionType] = this.actionHandlers[actionType].bind(this);
+      }
+    }
+  }
+  /**
+   * 暂停事件流执行
+   * @returns {Promise} 返回一个 Promise，在 resume 时 resolve
+   */
+  async pause() {
+    if (this.isPaused) {
+      throw new Error("事件流已经处于暂停状态");
+    }
+    this.isPaused = true;
+    this.pausePromise = new Promise((resolve, reject) => {
+      this.pauseResolve = resolve;
+      this.pauseReject = reject;
+    });
+    return this.pausePromise;
+  }
+  /**
+   * 获取执行结果
+   */
+  getExecutionResult() {
+    return {
+      success: true,
+      completed: true,
+      executionPath: this.executionPath,
+      context: this.context,
+      data: this.data
+    };
+  }
+  /**
+   * 获取当前节点信息
+   */
+  getCurrentNodeInfo() {
+    if (!this.currentNode) {
+      return null;
+    }
+    return {
+      id: this.currentNode.id,
+      type: this.currentNode.type,
+      name: this.currentNode.name,
+      isPaused: this.isPaused
+    };
+  }
+  /**
+   * 注册自定义动作处理器
+   * @param {String} actionType - 动作类型
+   * @param {Function} handler - 处理器函数 (node, data, fields) => Promise
+   */
+  registerActionHandler(actionType, handler) {
+    this.actionHandlers[actionType] = handler.bind(this);
+  }
+  /**
+   * 销毁解析器
+   */
+  destroy() {
+    if (this.isPaused) {
+      this.cancel("解析器被销毁");
+    }
+    this.eventFlow = null;
+    this.fields = [];
+    this.data = {};
+    this.currentNode = null;
+    this.executionPath = [];
+    this.context = {
+      variables: {},
+      results: []
+    };
+    this.actionHandlers = {};
+  }
+}
+function createEventFlowParser(options = {}) {
+  return new EventFlowParser(options);
+}
+exports.EventFlowParser = EventFlowParser;
+exports.NodeType = NodeType;
+exports.createEventFlowParser = createEventFlowParser;
+exports.default = EventFlowParser;

package/lib/packages/mobile/src/utils/formatterUtil.js

@@ -38,6 +38,7 @@ const cascadeFormatter = (value, options = []) => {
 };
 const dateFormatter = (value, dateType, formatterType) => {
   let dateValue;
+  debugger;
   if (!isNaN(value) && (value + "").length == 13) {
     dateValue = moment.default(Number(value));
   } else {

package/lib/packages/mobile/src/utils/idea/VueRender.vue.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const Vue = require("vue");
+const require$$1 = require("vue");
 const vue3sfc = require("./vue3sfc.js");
 ;/* empty css                */
 const _pluginVue_exportHelper = require("../../../../../_virtual/_plugin-vue_export-helper.js");
@@ -13,8 +13,8 @@ const _sfc_main = {
   },
   setup(__props) {
     const props = __props;
-    const dynamicComponent = Vue.ref(null);
-    Vue.watch(
+    const dynamicComponent = require$$1.ref(null);
+    require$$1.watch(
       () => props.code,
       async (val) => {
         if (!val) return;
@@ -27,8 +27,8 @@ const _sfc_main = {
       { immediate: true }
     );
     return (_ctx, _cache) => {
-      return Vue.openBlock(), Vue.createElementBlock("div", _hoisted_1, [
-        (Vue.openBlock(), Vue.createBlock(Vue.resolveDynamicComponent(dynamicComponent.value), Vue.normalizeProps(Vue.guardReactiveProps(__props.params)), null, 16))
+      return require$$1.openBlock(), require$$1.createElementBlock("div", _hoisted_1, [
+        (require$$1.openBlock(), require$$1.createBlock(require$$1.resolveDynamicComponent(dynamicComponent.value), require$$1.normalizeProps(require$$1.guardReactiveProps(__props.params)), null, 16))
       ]);
     };
   }

package/lib/packages/mobile/src/utils/idea/vue3sfc.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const vue3SfcLoader_esm = require("../../../../../node_modules/vue3-sfc-loader/dist/vue3-sfc-loader.esm.js");
-const Vue = require("vue");
+const require$$1 = require("vue");
 function _interopNamespaceDefault(e) {
   const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
   if (e) {
@@ -18,10 +18,10 @@ function _interopNamespaceDefault(e) {
   n.default = e;
   return Object.freeze(n);
 }
-const Vue__namespace = /* @__PURE__ */ _interopNamespaceDefault(Vue);
+const require$$1__namespace = /* @__PURE__ */ _interopNamespaceDefault(require$$1);
 const options = {
   moduleCache: {
-    vue: Vue__namespace
+    vue: require$$1__namespace
   },
   getFile: (url) => {
     return fetch(url).then((response) => {

package/lib/packages/mobile/src/utils/pageHistory.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const eventBus = require("./eventBus.js");
 const HISTORY_KEY = "mobile_page_history";
 const MAX_HISTORY_SIZE = 20;
 class PageHistory {
@@ -32,7 +33,7 @@ class PageHistory {
    * 添加页面到历史
    * @param {Object} page - 页面配置对象，需包含 id
    */
-  push(page) {
+  push(page, params) {
     if (!page || !page.id) {
       console.warn("页面配置无效，无法添加到历史");
       return;
@@ -44,14 +45,14 @@ class PageHistory {
       id: page.id,
       name: page.name || "",
       timestamp: Date.now(),
-      data: page
+      params
     });
     if (this.history.length > MAX_HISTORY_SIZE) {
       this.history.shift();
     }
     this.saveHistory();
   }
-  replace(page) {
+  replace(page, params) {
     if (!page || !page.id) {
       console.warn("页面配置无效，无法替换");
       return;
@@ -64,7 +65,7 @@ class PageHistory {
       id: page.id,
       name: page.name || "",
       timestamp: Date.now(),
-      data: page
+      params
     };
     this.saveHistory();
   }
@@ -79,7 +80,11 @@ class PageHistory {
     this.history.pop();
     this.saveHistory();
     const prevPage = this.history[this.history.length - 1];
-    return prevPage ? prevPage.data : null;
+    const pageId = prevPage ? prevPage.id : null;
+    const params = prevPage ? prevPage.params : null;
+    if (pageId) {
+      eventBus.default.emit("loadPage", { pageId, params });
+    }
   }
   /**
    * 获取当前页面
@@ -89,7 +94,7 @@ class PageHistory {
     if (this.history.length == 0) {
       return null;
     }
-    return this.history[this.history.length - 1].data;
+    return this.history[this.history.length - 1].id;
   }
   /**
    * 判断是否可以后退

package/lib/packages/mobile/src/utils/parseFilterConfig.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const parseRouteParams = require("./parseRouteParams.js");
+function isDateString(value) {
+  if (typeof value !== "string") return false;
+  return /^\d{4}\/\d{2}\/\d{2}$/.test(value);
+}
+function compareDate(a, b) {
+  return a.localeCompare(b);
+}
+function checkFilterMatch(filterConfig, data, fields = []) {
+  if (!filterConfig || !data) {
+    return false;
+  }
+  return checkGroupMatch(filterConfig, data, fields);
+}
+function checkGroupMatch(group, data, fields) {
+  const { operator, conditions, groups } = group;
+  const results = [];
+  if (conditions && conditions.length > 0) {
+    conditions.forEach((cond) => {
+      results.push(checkConditionMatch(cond, data, fields));
+    });
+  }
+  if (groups && groups.length > 0) {
+    groups.forEach((g) => {
+      results.push(checkGroupMatch(g, data, fields));
+    });
+  }
+  if (operator == "and") {
+    return results.every((r) => r == true);
+  } else {
+    return results.some((r) => r == true);
+  }
+}
+function checkConditionMatch(condition, data, fields) {
+  const { field, operator, value } = condition;
+  const fieldInfo = fields.find((f) => f.id == field);
+  const fieldName = (fieldInfo == null ? void 0 : fieldInfo.fieldName) || field;
+  const dataValue = data[fieldName];
+  const parsedValue = parseRouteParams.parseSingleParamValue(value, data, fields);
+  switch (operator) {
+    case "eq":
+      return dataValue == parsedValue;
+    case "ne":
+      return dataValue != parsedValue;
+    case "gt":
+      if (isDateString(dataValue) && isDateString(parsedValue)) {
+        return compareDate(dataValue, parsedValue) > 0;
+      }
+      return Number(dataValue) > Number(parsedValue);
+    case "gte":
+      if (isDateString(dataValue) && isDateString(parsedValue)) {
+        return compareDate(dataValue, parsedValue) >= 0;
+      }
+      return Number(dataValue) >= Number(parsedValue);
+    case "lt":
+      if (isDateString(dataValue) && isDateString(parsedValue)) {
+        return compareDate(dataValue, parsedValue) < 0;
+      }
+      return Number(dataValue) < Number(parsedValue);
+    case "lte":
+      if (isDateString(dataValue) && isDateString(parsedValue)) {
+        return compareDate(dataValue, parsedValue) <= 0;
+      }
+      return Number(dataValue) <= Number(parsedValue);
+    case "range":
+      if (!parsedValue || parsedValue.min == null || parsedValue.max == null) return false;
+      if (isDateString(dataValue) && isDateString(parsedValue.min) && isDateString(parsedValue.max)) {
+        return compareDate(dataValue, parsedValue.min) >= 0 && compareDate(dataValue, parsedValue.max) <= 0;
+      }
+      const numValue = Number(dataValue);
+      return numValue >= Number(parsedValue.min) && numValue <= Number(parsedValue.max);
+    case "contains":
+      if (!dataValue || !parsedValue) return false;
+      return String(dataValue).toLowerCase().includes(String(parsedValue).toLowerCase());
+    case "not_contains":
+      if (!dataValue || !parsedValue) return true;
+      return !String(dataValue).toLowerCase().includes(String(parsedValue).toLowerCase());
+    case "in_any":
+      if (!Array.isArray(parsedValue)) {
+        return dataValue == parsedValue;
+      }
+      return parsedValue.some((v) => dataValue == v);
+    case "ni_any":
+      if (!Array.isArray(parsedValue)) {
+        return dataValue != parsedValue;
+      }
+      return !parsedValue.some((v) => dataValue == v);
+    case "is_null":
+      return dataValue == null || dataValue == void 0 || dataValue == "";
+    case "is_not_null":
+      return dataValue !== null && dataValue !== void 0 && dataValue !== "";
+    default:
+      return dataValue == parsedValue;
+  }
+}
+exports.checkFilterMatch = checkFilterMatch;