@agentscope-ai/flow 0.0.1

package/dist/hooks/use-nodes-output-params.d.ts

@@ -0,0 +1,31 @@
+import { IVarItem, IVarTreeItem } from "../components/variable-tree-select";
+import { INodeDataOutputParamItem, IValueType, IWorkFlowNode } from "../types/work-flow";
+interface IQueryVariableListParams {
+    type?: IValueType;
+    scope?: 'sub' | 'global';
+    nodeId: string;
+    disableShowParentParams?: boolean;
+    disableShowVariableParameters?: boolean;
+}
+interface ArrayPathInfo {
+    fullPath: string;
+}
+export declare const buildOutputParamsTree: ({ outputParams, nodeId, parentKey, parentType, arrayPathStack, arrayWrap, flat, }: {
+    outputParams: Array<INodeDataOutputParamItem>;
+    nodeId: string;
+    parentKey?: string | undefined;
+    parentType?: string | undefined;
+    arrayPathStack?: ArrayPathInfo[] | undefined;
+    arrayWrap?: boolean | undefined;
+    flat?: boolean | undefined;
+}) => IVarItem[];
+export declare const filterVarItemsByType: (items: IVarItem[], types: IValueType[]) => IVarItem[];
+export declare const useNodesOutputParams: () => {
+    getVariableList: (params: IQueryVariableListParams) => IVarTreeItem[];
+    getSubNodesVariables: (nodeId: string) => IVarTreeItem[];
+    getSystemVariableList: () => IVarTreeItem[];
+    getOutputParamsFromNodesMap: (nodesMap: Record<string, IWorkFlowNode>, options?: {
+        arrayWrap?: boolean;
+    }) => IVarTreeItem[];
+};
+export {};

package/dist/hooks/use-nodes-output-params.js

@@ -0,0 +1,300 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+import { useStore } from "../flow/context";
+import $i18n from "../i18n";
+// import { getParentNodeVariableList } from '@/utils';
+import { getNeighborNodes } from "../utils/work-flow";
+import { useStoreApi } from '@xyflow/react';
+import { useCallback } from 'react';
+
+// 记录 Array<Object> 层级的完整路径信息
+
+export var buildOutputParamsTree = function buildOutputParamsTree(_ref) {
+  var outputParams = _ref.outputParams,
+    nodeId = _ref.nodeId,
+    _ref$parentKey = _ref.parentKey,
+    parentKey = _ref$parentKey === void 0 ? '' : _ref$parentKey,
+    _ref$parentType = _ref.parentType,
+    parentType = _ref$parentType === void 0 ? '' : _ref$parentType,
+    _ref$arrayPathStack = _ref.arrayPathStack,
+    arrayPathStack = _ref$arrayPathStack === void 0 ? [] : _ref$arrayPathStack,
+    _ref$arrayWrap = _ref.arrayWrap,
+    arrayWrap = _ref$arrayWrap === void 0 ? false : _ref$arrayWrap,
+    _ref$flat = _ref.flat,
+    flat = _ref$flat === void 0 ? false : _ref$flat;
+  var list = [];
+  var flatList = [];
+  var keySet = new Set();
+  var processItem = function processItem(item) {
+    if (!item.key || keySet.has(item.key)) return;
+    keySet.add(item.key);
+    var itemKey = parentKey ? "".concat(parentKey, ".").concat(item.key) : item.key;
+    var itemArrayPathStack = _toConsumableArray(arrayPathStack);
+    // 如果父节点是 Array<Object>，记录当前元素的完整路径
+    if (parentType.startsWith('Array')) {
+      itemArrayPathStack.push({
+        fullPath: itemKey
+      });
+    }
+
+    /* Build value format */
+    var valueFormat = '';
+    if (itemArrayPathStack.length > 0) {
+      /* Handle multi-level nested Array<Object> */
+      var pathParts = itemKey.split('.');
+
+      // 找到第一个 Array<Object> 的路径
+      var firstArrayPath = itemArrayPathStack[0].fullPath;
+      var firstArrayParts = firstArrayPath.split('.');
+
+      // baseProperty 是第一个 Array<Object> 之前的路径
+      var baseProperty = pathParts.slice(0, firstArrayParts.length - 1).join('.');
+
+      // 构建嵌套路径：需要在各个 Array<Object> 层级之间插入中间的普通 Object 路径
+      var nestedPath = '';
+
+      // 从最后一个数组层级开始向前构建
+      for (var i = itemArrayPathStack.length - 1; i >= 0; i--) {
+        var currentArrayPath = itemArrayPathStack[i].fullPath;
+        var currentArrayParts = currentArrayPath.split('.');
+        var currentArrayKey = currentArrayParts[currentArrayParts.length - 1];
+        if (i === itemArrayPathStack.length - 1) {
+          // 最后一层：包含从最后一个数组到当前元素的路径
+          var lastArrayParts = currentArrayParts;
+          var remainingParts = pathParts.slice(lastArrayParts.length);
+          nestedPath = remainingParts.length > 0 ? "".concat(currentArrayKey, ".").concat(remainingParts.join('.')) : currentArrayKey;
+        } else {
+          // 中间层：需要包含到下一个数组之间的路径
+          var nextArrayPath = itemArrayPathStack[i + 1].fullPath;
+          var nextArrayParts = nextArrayPath.split('.');
+
+          // 计算当前数组和下一个数组之间的中间路径
+          var middleParts = nextArrayParts.slice(currentArrayParts.length, nextArrayParts.length - 1);
+          var middlePath = middleParts.length > 0 ? "".concat(middleParts.join('.'), ".") : '';
+          nestedPath = "".concat(currentArrayKey, ".").concat(middlePath, "[").concat(nestedPath, "]");
+        }
+      }
+      if (arrayWrap) {
+        valueFormat = baseProperty ? "${".concat(nodeId, ".[").concat(baseProperty, ".[").concat(nestedPath, "]]}") : "${".concat(nodeId, ".[").concat(nestedPath, "]}");
+      } else {
+        valueFormat = baseProperty ? "${".concat(nodeId, ".").concat(baseProperty, ".[").concat(nestedPath, "]}") : "${".concat(nodeId, ".[").concat(nestedPath, "]}");
+      }
+    } else {
+      /* Normal property */
+      if (arrayWrap) {
+        /* If arrayWrap is true, wrap all properties as array structure */
+        var _pathParts = itemKey.split('.');
+        if (_pathParts.length === 1) {
+          /* Single-level property, e.g. ${Script_id.result} -> ${Script_id.[result]} */
+          valueFormat = "${".concat(nodeId, ".[").concat(itemKey, "]}");
+        } else {
+          /* Multi-level property, e.g. ${Script_id.result.name} -> ${Script_id.[result.name]} */
+          var _baseProperty = _pathParts[0];
+          var _nestedPath = _pathParts.slice(1).join('.');
+          valueFormat = "${".concat(nodeId, ".[").concat(_baseProperty, ".").concat(_nestedPath, "]}");
+        }
+      } else {
+        valueFormat = "${".concat(nodeId, ".").concat(itemKey, "}");
+      }
+    }
+
+    /* Generate new type based on arrayWrap and original type */
+    var newType;
+    if (arrayWrap) {
+      newType = "Array<".concat(item.type || 'String', ">");
+    } else {
+      newType = item.type;
+    }
+    var varItem = {
+      label: item.key,
+      value: valueFormat,
+      type: newType
+    };
+    if (flat) {
+      flatList.push(varItem);
+    }
+    if (item.properties && item.properties.length > 0) {
+      var childItems = buildOutputParamsTree({
+        outputParams: item.properties,
+        nodeId: nodeId,
+        parentKey: itemKey,
+        parentType: item.type,
+        arrayPathStack: itemArrayPathStack,
+        arrayWrap: arrayWrap,
+        flat: flat
+      });
+      if (childItems.length > 0) {
+        if (flat) {
+          flatList.push.apply(flatList, _toConsumableArray(childItems));
+        } else {
+          varItem.children = childItems;
+          list.push(varItem);
+        }
+      } else if (!flat) {
+        list.push(varItem);
+      }
+    } else if (!flat) {
+      list.push(varItem);
+    }
+  };
+  outputParams.forEach(processItem);
+  return flat ? flatList : list;
+};
+export var filterVarItemsByType = function filterVarItemsByType(items, types) {
+  return items.reduce(function (filtered, item) {
+    /* If the type of the current item matches, add it to the result */
+    var filteredItem = null;
+    if (types.includes(item.type)) {
+      filteredItem = item;
+    }
+
+    /* If there are children, recursively process the children */
+    if (item.children && item.children.length > 0) {
+      var filteredChildren = filterVarItemsByType(item.children, types);
+      if (filteredChildren.length > 0) {
+        /* If there are matches in the children, keep the current item and update its children */
+        filteredItem = _objectSpread(_objectSpread({}, item), {}, {
+          children: filteredChildren
+        });
+      }
+    }
+    filteredItem && filtered.push(filteredItem);
+    return filtered;
+  }, []);
+};
+export var useNodesOutputParams = function useNodesOutputParams() {
+  var store = useStoreApi();
+  var nodeSchemaMap = useStore(function (state) {
+    return state.nodeSchemaMap;
+  });
+  var getOutputParamsFromNodesMap = useCallback(function (nodesMap) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var outputParams = [];
+    Object.keys(nodesMap).forEach(function (nodeId) {
+      var _node$data$output_par;
+      var node = nodesMap[nodeId];
+      if (((_node$data$output_par = node.data.output_params) === null || _node$data$output_par === void 0 ? void 0 : _node$data$output_par.length) > 0) {
+        var varItems = buildOutputParamsTree(_objectSpread({
+          outputParams: node.data.output_params,
+          nodeId: nodeId
+        }, options));
+        if (varItems.length > 0) {
+          outputParams.push({
+            label: node.data.label || node.id,
+            nodeId: node.id,
+            nodeType: node.type,
+            children: varItems
+          });
+        }
+      }
+    });
+    return outputParams;
+  }, [store]);
+  var getSystemVariableList = useCallback(function () {
+    return [{
+      label: $i18n.get({
+        id: 'spark-flow.hooks.useNodesOutputParams.builtinVariable',
+        dm: '内置变量'
+      }),
+      nodeId: 'sys',
+      nodeType: 'sys',
+      children: [{
+        label: 'query',
+        value: '${sys.query}',
+        type: 'String'
+      }, {
+        label: 'history_list',
+        value: '${sys.history_list}',
+        type: 'Array<String>'
+      }]
+    }];
+  }, []);
+  var getSubNodesVariableList = useCallback(function (subNodes) {
+    var nodesMap = subNodes.reduce(function (acc, node) {
+      acc[node.id] = node;
+      return acc;
+    }, {});
+    var variableList = getOutputParamsFromNodesMap(nodesMap, {
+      arrayWrap: true
+    });
+    return variableList;
+  }, [store, getOutputParamsFromNodesMap]);
+  var getVariableList = useCallback(function (params) {
+    var nodeId = params.nodeId;
+    var _store$getState = store.getState(),
+      edges = _store$getState.edges,
+      nodes = _store$getState.nodes;
+    var targetNode = nodes.find(function (node) {
+      return node.id === nodeId;
+    });
+    if (!targetNode) return [];
+    var globalNodes = [];
+    var subNodes = [];
+    nodes.forEach(function (node) {
+      if (!node.parentId) {
+        /* Nodes without parentId belong to global nodes */
+        globalNodes.push(node);
+      } else if (node.parentId === targetNode.parentId) {
+        subNodes.push(node);
+      }
+    });
+
+    /* Get predecessor nodes */
+    var neighborNodesMap = {};
+    var parentVariableList = [];
+    if (targetNode.parentId) {
+      /* If it is a sub-node, get the predecessor nodes of the parent node or the predecessor nodes in the sub-canvas */
+      var parentNode = nodes.find(function (node) {
+        return node.id === targetNode.parentId;
+      });
+      if (parentNode) {
+        var _nodeSchemaMap;
+        if (!params.disableShowParentParams && !!((_nodeSchemaMap = nodeSchemaMap[parentNode.type]) !== null && _nodeSchemaMap !== void 0 && _nodeSchemaMap.getParentNodeVariableList)) {
+          var _nodeSchemaMap$getPar, _nodeSchemaMap2;
+          parentVariableList = ((_nodeSchemaMap$getPar = (_nodeSchemaMap2 = nodeSchemaMap[parentNode.type]).getParentNodeVariableList) === null || _nodeSchemaMap$getPar === void 0 ? void 0 : _nodeSchemaMap$getPar.call(_nodeSchemaMap2, parentNode, {
+            disableShowVariableParameters: params.disableShowVariableParameters
+          })) || [];
+        }
+        neighborNodesMap = _objectSpread(_objectSpread(_objectSpread({}, neighborNodesMap), getNeighborNodes({
+          nodes: globalNodes,
+          edges: edges,
+          nodeId: parentNode.id
+        })), getNeighborNodes({
+          nodes: subNodes,
+          edges: edges,
+          nodeId: targetNode.id
+        }));
+      }
+    } else {
+      neighborNodesMap = _objectSpread(_objectSpread({}, neighborNodesMap), getNeighborNodes({
+        nodes: globalNodes,
+        edges: edges,
+        nodeId: targetNode.id
+      }));
+    }
+    return [].concat(_toConsumableArray(parentVariableList), _toConsumableArray(getSystemVariableList()), _toConsumableArray(getOutputParamsFromNodesMap(neighborNodesMap)));
+  }, [store, getOutputParamsFromNodesMap, nodeSchemaMap]);
+  var getSubNodesVariables = useCallback(function (nodeId) {
+    var _store$getState2 = store.getState(),
+      nodes = _store$getState2.nodes;
+    return getSubNodesVariableList(nodes.filter(function (item) {
+      return item.parentId === nodeId;
+    }));
+  }, [store]);
+  return {
+    getVariableList: getVariableList,
+    getSubNodesVariables: getSubNodesVariables,
+    getSystemVariableList: getSystemVariableList,
+    getOutputParamsFromNodesMap: getOutputParamsFromNodesMap
+  };
+};

package/dist/hooks/use-nodes-update.d.ts

@@ -0,0 +1,9 @@
+import { IWorkFlowNodeData } from "../types/work-flow";
+type NodeDataUpdatePayload = {
+    id: string;
+    data: Partial<IWorkFlowNodeData>;
+};
+export declare const useNodeDataUpdate: () => {
+    handleNodeDataUpdate: ({ id, data }: NodeDataUpdatePayload) => void;
+};
+export {};

package/dist/hooks/use-nodes-update.js

@@ -0,0 +1,38 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { useStoreApi } from '@xyflow/react';
+import { useCallback } from 'react';
+import { useFlowSave } from "./use-flow-save";
+import { useNodesReadOnly } from "./use-work-flow";
+export var useNodeDataUpdate = function useNodeDataUpdate() {
+  var store = useStoreApi();
+  var _useFlowSave = useFlowSave(),
+    handleSaveFlowDraft = _useFlowSave.handleSaveFlowDraft;
+  var _useNodesReadOnly = useNodesReadOnly(),
+    getNodesReadOnly = _useNodesReadOnly.getNodesReadOnly;
+  var handleNodeDataUpdate = useCallback(function (_ref) {
+    var id = _ref.id,
+      data = _ref.data;
+    if (getNodesReadOnly()) return;
+    var _store$getState = store.getState(),
+      nodes = _store$getState.nodes,
+      setNodes = _store$getState.setNodes;
+    var newNodes = nodes.map(function (node) {
+      if (node.id === id) {
+        return _objectSpread(_objectSpread({}, node), {}, {
+          data: _objectSpread(_objectSpread({}, node.data), data)
+        });
+      }
+      return node;
+    });
+    setNodes(newNodes);
+    handleSaveFlowDraft();
+  }, [store, handleSaveFlowDraft]);
+  return {
+    handleNodeDataUpdate: handleNodeDataUpdate
+  };
+};

package/dist/hooks/use-work-flow.d.ts

@@ -0,0 +1,4 @@
+export declare const useNodesReadOnly: () => {
+    nodesReadOnly: boolean;
+    getNodesReadOnly: () => boolean;
+};

package/dist/hooks/use-work-flow.js

@@ -0,0 +1,21 @@
+import { useCallback } from 'react';
+import { WorkflowRunningStatus } from "../constant";
+import { useStore, useWorkflowStore } from "../flow/context";
+export var useNodesReadOnly = function useNodesReadOnly() {
+  var workflowStore = useWorkflowStore();
+  var taskStore = useStore(function (s) {
+    return s.taskStore;
+  });
+  var readyOnly = useStore(function (s) {
+    return s.readyOnly;
+  });
+  var getNodesReadOnly = useCallback(function () {
+    var _workflowStore$getSta = workflowStore.getState(),
+      taskStore = _workflowStore$getSta.taskStore;
+    return [WorkflowRunningStatus.Running, WorkflowRunningStatus.Paused].includes((taskStore === null || taskStore === void 0 ? void 0 : taskStore.task_status) || '') || readyOnly;
+  }, [workflowStore, readyOnly]);
+  return {
+    nodesReadOnly: [WorkflowRunningStatus.Running, WorkflowRunningStatus.Paused].includes((taskStore === null || taskStore === void 0 ? void 0 : taskStore.task_status) || '') || readyOnly,
+    getNodesReadOnly: getNodesReadOnly
+  };
+};

package/dist/i18n/i18n.d.ts

@@ -0,0 +1,62 @@
+interface I18nVariables {
+    [key: string]: any;
+}
+interface IMultiLangMap {
+    [key: string]: {
+        [key: string]: string;
+    };
+}
+type TLanguage = 'en' | 'zh' | 'ja' | string;
+/**
+ * Internationalization (i18n) utility class
+ * Handles language management and string translations
+ */
+export default class I18N {
+    multiLangMap: IMultiLangMap;
+    language: TLanguage;
+    /**
+     * Initialize I18N instance with multi-language map
+     * @param config Configuration object containing multiLangMap
+     */
+    constructor({ multiLangMap }: {
+        multiLangMap: IMultiLangMap;
+    });
+    /**
+     * Convert value to string with fallback
+     * @param value Input value to convert
+     * @param defaultValue Fallback value if conversion fails
+     * @returns String representation of the value
+     */
+    toString: (value: any, defaultValue: string) => any;
+    /**
+     * Set current application language
+     * @param language Language code to set ('en' or 'zh')
+     */
+    setCurrentLanguage(language: TLanguage): void;
+    /**
+     * Get current application language
+     * @returns Current language code
+     */
+    getCurrentLanguage(): string;
+    /**
+     * Format translation string with variables
+     * @param idObj Translation ID or object containing ID and default message
+     * @param variables Variables to interpolate into the translation
+     * @returns Formatted translation string
+     */
+    format: (idObj: string | {
+        id: string;
+        dm: string;
+    }, variables: I18nVariables) => string;
+    /**
+     * Get translation for given ID
+     * @param id Translation ID or object containing ID and default message
+     * @param variables Optional variables to interpolate
+     * @returns Translated string
+     */
+    get(id: string | {
+        id: string;
+        dm: string;
+    }, variable?: I18nVariables): string;
+}
+export {};

package/dist/i18n/i18n.js

@@ -0,0 +1,111 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import dayjs from 'dayjs';
+
+// Interface for translation variables
+
+// Interface for multi-language mapping
+
+// Supported language types
+/**
+ * Internationalization (i18n) utility class
+ * Handles language management and string translations
+ */
+var I18N = /*#__PURE__*/function () {
+  /**
+   * Initialize I18N instance with multi-language map
+   * @param config Configuration object containing multiLangMap
+   */
+  function I18N(_ref) {
+    var _this = this;
+    var _multiLangMap = _ref.multiLangMap;
+    _classCallCheck(this, I18N);
+    _defineProperty(this, "multiLangMap", void 0);
+    _defineProperty(this, "language", void 0);
+    /**
+     * Convert value to string with fallback
+     * @param value Input value to convert
+     * @param defaultValue Fallback value if conversion fails
+     * @returns String representation of the value
+     */
+    _defineProperty(this, "toString", function (value, defaultValue) {
+      if (value === undefined || value === null) {
+        return defaultValue;
+      }
+      if (typeof value === 'string') {
+        return value;
+      }
+      if (value !== null && value !== void 0 && value.toString && typeof value.toString === 'function') {
+        return value.toString();
+      }
+      return value || defaultValue;
+    });
+    /**
+     * Format translation string with variables
+     * @param idObj Translation ID or object containing ID and default message
+     * @param variables Variables to interpolate into the translation
+     * @returns Formatted translation string
+     */
+    _defineProperty(this, "format", function (idObj, variables) {
+      var multiLangMap = _this.multiLangMap,
+        language = _this.language;
+      var langMap = multiLangMap[language] || {};
+      var template = '';
+      if (typeof idObj === 'string') {
+        template = langMap[idObj] || idObj;
+      } else {
+        var id = idObj.id,
+          dm = idObj.dm;
+        template = langMap[id] || dm || id;
+      }
+      return template.replace(/\{(\w+)\}/g, function (_match, key) {
+        return _this.toString(variables[key], _match);
+      });
+    });
+    this.multiLangMap = _multiLangMap;
+    this.language = localStorage.getItem('spark-flow-data-prefers-language') || 'en';
+    dayjs.locale(this.language);
+  }
+  _createClass(I18N, [{
+    key: "setCurrentLanguage",
+    value:
+    /**
+     * Set current application language
+     * @param language Language code to set ('en' or 'zh')
+     */
+    function setCurrentLanguage(language) {
+      localStorage.setItem('spark-flow-data-prefers-language', language);
+      this.language = language;
+      dayjs.locale(language);
+    }
+
+    /**
+     * Get current application language
+     * @returns Current language code
+     */
+  }, {
+    key: "getCurrentLanguage",
+    value: function getCurrentLanguage() {
+      return this.language;
+    }
+  }, {
+    key: "get",
+    value:
+    /**
+     * Get translation for given ID
+     * @param id Translation ID or object containing ID and default message
+     * @param variables Optional variables to interpolate
+     * @returns Translated string
+     */
+    function get(id, variable) {
+      return this.format(id, variable || {});
+    }
+  }]);
+  return I18N;
+}();
+export { I18N as default };

package/dist/i18n/index.d.ts

@@ -0,0 +1,3 @@
+import I18N from './i18n';
+declare const _default: I18N;
+export default _default;

package/dist/i18n/index.js

@@ -0,0 +1,12 @@
+import I18N from "./i18n";
+import enLangMap from "./locales/en-us.json";
+import jaLangMap from "./locales/ja-jp.json";
+import cnLangMap from "./locales/zh-cn.json";
+var multiLangMap = {
+  zh: cnLangMap,
+  en: enLangMap,
+  ja: jaLangMap
+};
+export default new I18N({
+  multiLangMap: multiLangMap
+});