@luck-design-biz/luckda 0.0.25-8 → 0.0.25-af-1

package/es/lowcode/engine/provider/ContextProvider/index.js

@@ -1,46 +1,55 @@
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
-import React, { createContext, useContext as useReactContext, useRef } from 'react';
+var _excluded = ["source"];
+import React, { createContext, useContext, useRef, useEffect } from 'react';
 import { history } from 'umi';
-import { useMemoizedFn, useSetState, useUpdateEffect, usePrevious } from 'ahooks';
+import { useRequest, useMemoizedFn, useSetState } from 'ahooks';
 import { useLDEventBus } from "../EventBusProvider";
-import RemoteSourceProvider, { RemoteSourceContext } from "../RemoteSourceProvider";
-import useTodo from "../../tools/useTodo";
+import usePromiseState from "../../tools/usePromiseState";
 import * as topics from "../../../constants/event-topics";
+import { decompress } from "../../tools/dataProcess";
+import { executeCode } from "../../tools/helper";
+import { fetchPageData } from "../../../constants/api-url";
 export var Context = /*#__PURE__*/createContext(null);
-export var useContext = function useContext() {
-  return useReactContext(Context);
+export var useLDContext = function useLDContext() {
+  return useContext(Context);
 };
-export var useRemoteSource = function useRemoteSource() {
-  return useReactContext(RemoteSourceContext);
-};
-export * from "../../tools/usePageDataStore";
-var PRIVATE_KEYS = ['componentList', 'componentMap'];
+var PRIVATE_KEYS = ['pageinfo', 'componentList', 'componentMap'];
 export default (function (_ref) {
   var children = _ref.children,
-    code = _ref.code,
-    debug = _ref.debug;
+    code = _ref.code;
   var eventBus = useLDEventBus();
-  var _useTodo = useTodo(),
-    _useTodo2 = _slicedToArray(_useTodo, 3),
-    todo = _useTodo2[0],
-    callBehavior = _useTodo2[1],
-    loading = _useTodo2[2];
 
-  /**
-   * 页面公共资源
+  /**
+   * 页面数据
+   */
+  var _usePromiseState = usePromiseState(null),
+    _usePromiseState2 = _slicedToArray(_usePromiseState, 2),
+    pageData = _usePromiseState2[0],
+    _setPageData = _usePromiseState2[1];
+
+  /**
+   * 页面信息
+   */
+  var _pageinfo = useRef(null);
+
+  /**
+   * 页面公共资源
    */
   var _useSetState = useSetState(null),
     _useSetState2 = _slicedToArray(_useSetState, 2),
     pagePublicResource = _useSetState2[0],
-    setPagePublicResource = _useSetState2[1];
-  var prevPagePublicResource = usePrevious(pagePublicResource);
+    _setPagePublicResource = _useSetState2[1];
 
-  /**
-   * 组件列表
+  /**
+   * 组件列表
    */
   var _componentList = useRef([]);
   var _privateGetter = useRef({
+    pageinfo: function pageinfo() {
+      return _pageinfo.current;
+    },
     componentList: function componentList() {
       return _componentList.current;
     },
@@ -49,18 +58,18 @@ export default (function (_ref) {
     }
   });
 
-  /**
-   * 注册组件
-   * id:string 组件id
-   * component:ReactNode 组件
+  /**
+   * 注册组件
+   * id:string 组件id
+   * component:ReactNode 组件
    */
   var _register = useMemoizedFn(function (id, component) {
     _componentList.current.push([id, component]);
   });
 
-  /**
-   * 注销组件
-   * id:string 组件id
+  /**
+   * 注销组件
+   * id:string 组件id
    */
   var _unregister = useMemoizedFn(function (id) {
     _componentList.current = _componentList.current.filter(function (_ref2) {
@@ -70,62 +79,101 @@ export default (function (_ref) {
     });
   });
 
-  /**
-   * 根据组件id获取组件
-   * compId:string 组件id
-   * return:ReactNode
+  /**
+   * 根据组件id获取组件
+   * compId:string 组件id
+   * return:ReactNode
    */
   var getElementById = useMemoizedFn(function (compId) {});
 
-  /**
-   * 根据组件id获取父组件
-   * compId:string 组件id
-   * return:ReactNode
+  /**
+   * 根据组件id获取父组件
+   * compId:string 组件id
+   * return:ReactNode
    */
   var getParentElement = useMemoizedFn(function (compId) {});
 
-  /**
-   * 根据组件id获取组件路径
-   * compId:string 组件id
-   * return:ReactNode
+  /**
+   * 根据组件id获取组件路径
+   * compId:string 组件id
+   * return:ReactNode
    */
   var getElementPathById = useMemoizedFn(function (compId) {});
 
-  /**
-   * 获取url参数
-   * return:object
+  /**
+   * 获取当前模块数据
+   * return:Object
+   */
+  var getModule = useMemoizedFn(function () {});
+
+  /**
+   * 根据datasetId获取数据集
+   * datasetId:string 数据集id
+   * return:Object
+   */
+  var getDataSetById = useMemoizedFn(function (datasetId) {});
+
+  /**
+   * 获取url参数
+   * return:object
    */
   var getUrlParams = useMemoizedFn(function () {});
-  useUpdateEffect(function () {
-    eventBus.$publisher(topics.PAGE_PUBLIC_RESOURCE_CHANGED, {
-      resource: pagePublicResource,
-      prevResource: prevPagePublicResource
+  var doAction = useMemoizedFn(function (action) {
+    executeCode(ctx, action.actionCode);
+    Promise.all(action.actionPool.map(function (actionKey) {
+      return new Promise(function (resolve) {
+        setTimeout(function () {
+          console.log("doAction:".concat(actionKey));
+          resolve(actionKey);
+        }, 400);
+      });
+    })).then();
+  });
+  var _useRequest = useRequest(fetchPageData, {
+      manual: true
+    }),
+    loading = _useRequest.loading,
+    runFetchPageData = _useRequest.runAsync;
+  useEffect(function () {
+    runFetchPageData(code).then(function (_ref4) {
+      var code = _ref4.code,
+        data = _ref4.data,
+        list = _ref4.list,
+        detail = _ref4.detail;
+      if (code === 1) {
+        var _detail$list$ = detail[list[0]],
+          source = _detail$list$.source,
+          info = _objectWithoutProperties(_detail$list$, _excluded);
+        _pageinfo.current = _objectSpread({
+          relationship: data
+        }, info);
+        _setPageData(decompress(source));
+      }
     });
-  }, [pagePublicResource]);
+  }, [code]);
   var ctx = new Proxy(_objectSpread({
+    _setPageData: _setPageData,
     _register: _register,
     _unregister: _unregister,
-    pagePublicResource: pagePublicResource,
-    setPagePublicResource: setPagePublicResource,
     loading: loading,
+    pageData: pageData,
+    pagePublicResource: pagePublicResource,
     history: history,
-    callBehavior: callBehavior,
     topics: topics,
-    PRIMARY_KEY: window.appConfig.constraintKeys.PRIMARY,
     getElementById: getElementById,
-    /**
-     * @method
-     * @param {string} id - 组件id
-     * @return {object}
+    /**
+     * @method
+     * @param {string} id - 组件id
+     * @return {object}
      */
     getParentElement: getParentElement,
     getElementPathById: getElementPathById,
-    doAction: function doAction(actionPool, args) {
-      return todo(this, actionPool, args);
-    },
-    /**
-     * @method
-     * @return {object}
+    getModule: getModule,
+    getDataSetById: getDataSetById,
+    doAction: doAction,
+    /**
+     * @method
+     * @return {object}
      */
     getUrlParams: getUrlParams
   }, eventBus), {
@@ -137,6 +185,7 @@ export default (function (_ref) {
       return Reflect.get(target, property, receiver);
     },
     set: function set(target, property, receiver) {
+      console.log('set', target, property, receiver);
       if (PRIVATE_KEYS.includes(property)) {
         throw new Error("\u5C5E\u6027 \"".concat(property, "\" \u662F\u53EA\u8BFB\u7684"));
       } else {
@@ -146,9 +195,5 @@ export default (function (_ref) {
   });
   return /*#__PURE__*/React.createElement(Context.Provider, {
     value: ctx
-  }, /*#__PURE__*/React.createElement(RemoteSourceProvider, {
-    code: code,
-    runtime: eventBus.runtime,
-    debug: debug
-  }, children));
+  }, children);
 });

package/es/lowcode/engine/tools/dataProcess.js

@@ -3,12 +3,12 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
 import _typeof from "@babel/runtime/helpers/esm/typeof";
 import * as LZString from 'lz-string';
-import { LC_BUILDIN_UNIT_KEY } from "../../constants";
+import { CELL_KEY } from "../../constants";
 
-/**
- * 数据压缩
- * @param {JSON} data
- * @returns 加密后的字符串
+/**
+ * 数据压缩
+ * @param {JSON} data
+ * @returns 加密后的字符串
  */
 export function compress(data) {
   // 将对象转换为JSON字符串
@@ -17,10 +17,10 @@ export function compress(data) {
   return LZString.compressToBase64(jsonString);
 }
 
-/**
- * 数据解压
- * @param {string} compressedData
- * @returns {json}
+/**
+ * 数据解压
+ * @param {string} compressedData
+ * @returns {json}
  */
 export function decompress(compressedData) {
   // 使用LZ-String解压数据
@@ -29,20 +29,16 @@ export function decompress(compressedData) {
   return JSON.parse(jsonString);
 }
 
-/**
- * 查找指定ID的节点及其父节点。
- *
- * @param {string} id - 要查找的节点ID。
- * @param {Object} current - 当前遍历的JSON对象。
- * @param {Object|null} parent - 当前节点的父节点。
- * @returns {{node: Object|null, parent: Object|null}} 查找结果，包含节点和其父节点。
+/**
+ * 查找指定ID的节点及其父节点。
+ *
+ * @param {string} id - 要查找的节点ID。
+ * @param {Object} current - 当前遍历的JSON对象。
+ * @param {Object|null} parent - 当前节点的父节点。
+ * @returns {{node: Object|null, parent: Object|null}} 查找结果，包含节点和其父节点。
  */
 export function findNodeAndParent(id, current) {
   var parent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-  if (!id) return {
-    node: null,
-    parent: null
-  };
   if (!parent && current.props.id === id) {
     return {
       node: current,
@@ -69,13 +65,13 @@ export function findNodeAndParent(id, current) {
   };
 }
 
-/**
- * 对指定的JSON结构进行节点的添加、修改或删除操作。
- *
- * @param {Object} json - 要操作的JSON对象。
- * @param {string|null} path - 要操作的节点路径，使用'/'分隔。
- * @param {string} id - 操作节点的唯一标识符。
- * @param {Object|null} data - 要添加或修改的数据。如果为null，表示删除操作。
+/**
+ * 对指定的JSON结构进行节点的添加、修改或删除操作。
+ *
+ * @param {Object} json - 要操作的JSON对象。
+ * @param {string|null} path - 要操作的节点路径，使用'/'分隔。
+ * @param {string} id - 操作节点的唯一标识符。
+ * @param {Object|null} data - 要添加或修改的数据。如果为null，表示删除操作。
  */
 function process(json, path, id, data) {
   if (!json) {
@@ -141,113 +137,51 @@ function process(json, path, id, data) {
   }
 }
 
-/**
- * 对指定的JSON结构进行节点的添加操作。
- *
- * @param {Object} json - 要操作的JSON对象。
- * @param {string} parentId - 父节点的唯一标识符。
- * @param {string} id - 操作节点的唯一标识符。
- * @param {Object|null} data - 要添加或修改的数据。如果为null，表示删除操作。
+/**
+ * 对指定的JSON结构进行节点的添加操作。
+ *
+ * @param {Object} json - 要操作的JSON对象。
+ * @param {string} parentId - 父节点的唯一标识符。
+ * @param {string} id - 操作节点的唯一标识符。
+ * @param {Object|null} data - 要添加或修改的数据。如果为null，表示删除操作。
  */
 export function add(json, parentId, id, data) {
   process(json, getPathById(json, parentId), id, data);
 }
 
-/**
- * 移动指定的节点到另一个节点的指定位置。
- *
- * @param {Object} json - 要操作的JSON对象。
- * @param {string} sid - 被移动的节点id
- * @param {string} tid - 目标节点id
- * @param {string} action - 'left': 往节点前面插入，'right'：往节点后面插，'inside'：往节点子节点插
- */
-export function move(json, sid, tid, action) {
-  // 验证节点存在性
-  var _findNodeAndParent3 = findNodeAndParent(sid, json),
-    sourceNode = _findNodeAndParent3.node,
-    sourceParent = _findNodeAndParent3.parent;
-  var _findNodeAndParent4 = findNodeAndParent(tid, json),
-    targetNode = _findNodeAndParent4.node,
-    targetParent = _findNodeAndParent4.parent;
-  if (!sourceNode || !targetNode) {
-    throw new Error('Source or target node does not exist.');
-  }
-
-  // 从原父节点中移除
-  if (sourceParent) {
-    sourceParent.children = sourceParent.children.filter(function (id) {
-      return id !== sid;
-    });
-    if (sourceParent.children.length === 0) {
-      delete sourceParent.children;
-    }
-    delete sourceParent[sid];
-  }
-  switch (action) {
-    case 'inside':
-      // 插入到目标节点的children数组
-      if (!targetNode.children) {
-        targetNode.children = [];
-      }
-      targetNode.children.push(sid);
-      sourceNode.props.parentId = tid;
-      targetNode[sid] = sourceNode;
-      break;
-    case 'left':
-    case 'right':
-      if (!targetParent) {
-        throw new Error('Target node must have a parent for left or right operations.');
-      }
-      // 插入到目标节点同级的前面或后面
-      var idx = targetParent.children.indexOf(tid);
-      if (idx === -1) {
-        throw new Error("Target node is not found in its parent's children list.");
-      }
-      if (action === 'right') {
-        idx++;
-      }
-      targetParent.children.splice(idx, 0, sid);
-      sourceNode.props.parentId = targetParent.props.id;
-      targetParent[sid] = sourceNode;
-      break;
-    default:
-      throw new Error('Invalid action type.');
-  }
-}
-
-/**
- * 对指定的JSON结构进行节点的修改操作。
- *
- * @param {Object} json - 要操作的JSON对象。
- * @param {string} id - 操作节点的唯一标识符。
- * @param {Object|null} data - 要添加或修改的数据。如果为null，表示删除操作。
+/**
+ * 对指定的JSON结构进行节点的修改操作。
+ *
+ * @param {Object} json - 要操作的JSON对象。
+ * @param {string} id - 操作节点的唯一标识符。
+ * @param {Object|null} data - 要添加或修改的数据。如果为null，表示删除操作。
  */
 export function modifyById(json, id, data) {
   process(json, null, id, data);
 }
 
-/**
- * 删除指定id的节点。
- *
- * @param {Object} json - JSON对象。
- * @param {string} id - 要删除的节点ID。
+/**
+ * 删除指定id的节点。
+ *
+ * @param {Object} json - JSON对象。
+ * @param {string} id - 要删除的节点ID。
  */
 export function deleteById(json, id) {
   process(json, null, id);
 }
 
-/**
- * 根据ID在给定的JSON结构中查找节点的路径。
- *
- * @param {Object} json - 要搜索的JSON对象。
- * @param {string} id - 要查找的节点ID。
- * @param {string} currentPath - 当前递归到的路径，用于构建返回的路径字符串。
- * @returns {string|null} 如果找到节点，返回节点的路径；否则返回null。
+/**
+ * 根据ID在给定的JSON结构中查找节点的路径。
+ *
+ * @param {Object} json - 要搜索的JSON对象。
+ * @param {string} id - 要查找的节点ID。
+ * @param {string} currentPath - 当前递归到的路径，用于构建返回的路径字符串。
+ * @returns {string|null} 如果找到节点，返回节点的路径；否则返回null。
  */
 export function getPathById(json, id) {
   var currentPath = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
   for (var key in json) {
-    if (id === LC_BUILDIN_UNIT_KEY.PAGE_ROOT) return '/';
+    if (id === CELL_KEY.PAGE_ROOT) return '/';
     var newPath = currentPath ? "".concat(currentPath, "/").concat(key) : key;
     if (json[key].props && json[key].props.id === id) {
       return newPath;
@@ -262,28 +196,28 @@ export function getPathById(json, id) {
   return null;
 }
 
-/**
- * 在给定的JSON结构中搜索具有特定id的节点，并返回包含该节点及其所有父节点的props属性的路径数组。
- *
- * @param {Object} data - 待搜索的JSON对象，它代表了一个复杂的树状结构，每个节点都可能有props和children属性。
- * @param {string} targetId - 需要找到的目标节点的id。
- * @returns {Array<Object>} 一个包含目标节点及其所有父节点的props属性的数组。如果未找到目标节点，则返回空数组。
- *
- * @example
- * const data = {
- *   props: {
- *     id: 'page_root',
- *     type: 'Page',
- *     name: '页面',
- *     hasHeder: true,
- *     hasFooter: true,
- *   },
- *   // ...其他节点
- * };
- *
- * const path = getPathNodesById(data, 'form_jknbjkun');
- * console.log(path);
- * // 输出目标节点及其所有父节点的props属性的数组
+/**
+ * 在给定的JSON结构中搜索具有特定id的节点，并返回包含该节点及其所有父节点的props属性的路径数组。
+ *
+ * @param {Object} data - 待搜索的JSON对象，它代表了一个复杂的树状结构，每个节点都可能有props和children属性。
+ * @param {string} targetId - 需要找到的目标节点的id。
+ * @returns {Array<Object>} 一个包含目标节点及其所有父节点的props属性的数组。如果未找到目标节点，则返回空数组。
+ *
+ * @example
+ * const data = {
+ *   props: {
+ *     id: 'page_root',
+ *     type: 'Page',
+ *     name: '页面',
+ *     hasHeder: true,
+ *     hasFooter: true,
+ *   },
+ *   // ...其他节点
+ * };
+ *
+ * const path = getPathNodesById(data, 'form_jknbjkun');
+ * console.log(path);
+ * // 输出目标节点及其所有父节点的props属性的数组
  */
 export function getPathNodesById(data, targetId) {
   // 初始化结果数组

package/es/lowcode/engine/tools/helper.js

@@ -3,7 +3,6 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 import _typeof from "@babel/runtime/helpers/esm/typeof";
 import { omit, omitBy, startsWith, isNil, isString, isArray } from 'lodash';
-import postcss from 'postcss';
 export function isPromise(value) {
   return !!value && _typeof(value) === 'object' && typeof value.then === 'function';
 }
@@ -13,91 +12,69 @@ export function omitBadProps(props) {
 }
 export function listReducer(state, action) {
   switch (action.type) {
-    case 'insert':
+    case 'add':
       {
         var _action$callback;
-        var newState = _toConsumableArray(state);
-        newState.splice(action.payload.index + 1, 0, action.payload.data);
+        var newState = [].concat(_toConsumableArray(state), [action.payload]);
         (_action$callback = action.callback) === null || _action$callback === void 0 || _action$callback.call(action, newState);
         return newState;
       }
-    case 'add':
+    case 'delete':
       {
         var _action$callback2;
-        var _newState = [].concat(_toConsumableArray(state), [action.payload]);
+        var _newState = state.filter(function (item) {
+          return item.id !== action.payload;
+        });
         (_action$callback2 = action.callback) === null || _action$callback2 === void 0 || _action$callback2.call(action, _newState);
         return _newState;
       }
-    case 'delete':
+    case 'edit':
       {
         var _action$callback3;
-        var _newState2 = state.filter(function (item) {
-          return item.id !== action.payload;
+        var _newState2 = state.map(function (item) {
+          return item.id === action.payload.id ? _objectSpread(_objectSpread({}, item), action.payload.data) : item;
         });
         (_action$callback3 = action.callback) === null || _action$callback3 === void 0 || _action$callback3.call(action, _newState2);
         return _newState2;
       }
-    case 'edit':
+    case 'active':
       {
         var _action$callback4;
         var _newState3 = state.map(function (item) {
+          item.active = false;
           return item.id === action.payload.id ? _objectSpread(_objectSpread({}, item), action.payload.data) : item;
         });
         (_action$callback4 = action.callback) === null || _action$callback4 === void 0 || _action$callback4.call(action, _newState3);
         return _newState3;
       }
-    case 'batchEdit':
+    case 'new':
       {
         var _action$callback5;
-        var _newState4 = state.map(function (item) {
-          var newItem = action.payload.items.find(function (_id) {
-            return _id === item.id;
-          });
-          if (newItem) {
-            return _objectSpread(_objectSpread({}, item), action.payload.data);
-          }
-          return item;
-        });
+        var _newState4 = _toConsumableArray(action.payload);
         (_action$callback5 = action.callback) === null || _action$callback5 === void 0 || _action$callback5.call(action, _newState4);
         return _newState4;
       }
-    case 'active':
-      {
-        var _action$callback6;
-        var _newState5 = state.map(function (item) {
-          item.active = false;
-          return item.id === action.payload.id ? _objectSpread(_objectSpread({}, item), action.payload.data) : item;
-        });
-        (_action$callback6 = action.callback) === null || _action$callback6 === void 0 || _action$callback6.call(action, _newState5);
-        return _newState5;
-      }
-    case 'init':
-    case 'new':
-      {
-        var _action$callback7;
-        (_action$callback7 = action.callback) === null || _action$callback7 === void 0 || _action$callback7.call(action, action.payload);
-        return action.payload;
-      }
     case 'sort':
       {
-        var _action$callback8;
+        var _action$callback6;
         var sortItems = action.payload;
         var newItems = state.sort(function (a, b) {
           var indexA = sortItems.indexOf(a.id);
           var indexB = sortItems.indexOf(b.id);
           return indexA - indexB;
         });
-        var _newState6 = _toConsumableArray(newItems);
-        (_action$callback8 = action.callback) === null || _action$callback8 === void 0 || _action$callback8.call(action, _newState6);
-        return _newState6;
+        (_action$callback6 = action.callback) === null || _action$callback6 === void 0 || _action$callback6.call(action, _newState5);
+        var _newState5 = _toConsumableArray(newItems);
+        return _newState5;
       }
     default:
       throw new Error();
   }
 }
 export function getCtx(context) {
-  return context;
-  // return omitBy(context, (_, key) => startsWith(key, '_'));
+  return omitBy(context, function (_, key) {
+    return startsWith(key, '_');
+  });
 }
 export function getFuncBody(funcCode) {
   var regex = /{([\s\S]*?)}(?![\s\S]*})/;
@@ -120,31 +97,4 @@ export function executeCode(context, code, argsName) {
   var ctx = getCtx(context);
   var func = _construct(Function, _toConsumableArray(argsName || []).concat(['ctx', getFuncBody(code)]));
   return func.apply(void 0, args.concat([ctx]));
-}
-export function parseCSS(cssString) {
-  // 创建一个空对象来存储解析后的样式
-  var parsedStyles = {};
-  if (cssString) {
-    try {
-      // 解析CSS字符串
-      var ast = postcss.parse(cssString);
-
-      // 遍历AST中的每个规则
-      ast.walkDecls(function (decl) {
-        // 将每个声明的属性和值存储在对象中
-        parsedStyles[decl.prop] = decl.value;
-      });
-    } catch (e) {
-      console.error(e);
-    }
-  }
-
-  // 返回包含所有样式的对象
-  return parsedStyles;
-}
-;
-export function isColor(str) {
-  var hexRegex = /^#(?:[A-Fa-f0-9]{3,4}){1,2}$/;
-  var rgbaRegex = /^rgba?\(\s*(\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})(,\s*(0|1|0?\.\d+))?\s*\)$/;
-  return hexRegex.test(str) || rgbaRegex.test(str);
 }