@mybricks/to-code-taro 1.0.0

package/dist/esm/utils/index.js

@@ -0,0 +1,345 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import pxtransform from "./pxtransform";
+
+// 临时类型定义，实际使用时应该从 code-next 导入
+
+/** 导入依赖收集、解析 */
+export var ImportManager = /*#__PURE__*/function () {
+  function ImportManager(_config) {
+    _classCallCheck(this, ImportManager);
+    _defineProperty(this, "_imports", {});
+    this._config = _config;
+  }
+
+  /** 添加依赖 */
+  _createClass(ImportManager, [{
+    key: "addImport",
+    value: function addImport(_ref) {
+      var packageName = _ref.packageName,
+        dependencyNames = _ref.dependencyNames,
+        importType = _ref.importType;
+      if (!packageName) {
+        return;
+      }
+      var _imports = this._imports;
+      if (!_imports[packageName]) {
+        _imports[packageName] = {};
+      }
+
+      // 对于 module 类型且 dependencyNames 为空的情况，使用特殊标记
+      if (importType === "module" && dependencyNames.length === 0) {
+        _imports[packageName]["__module__"] = {
+          importType: "module"
+        };
+      } else {
+        dependencyNames.forEach(function (dependencyName) {
+          _imports[packageName][dependencyName] = {
+            importType: importType
+          };
+        });
+      }
+    }
+
+    /** 依赖解析为code */
+  }, {
+    key: "toCode",
+    value: function toCode() {
+      var indent = indentation(this._config.codeStyle.indent);
+      return Object.entries(this._imports).reduce(function (pre, _ref2) {
+        var _dependencies$__modul;
+        var _ref3 = _slicedToArray(_ref2, 2),
+          packageName = _ref3[0],
+          dependencies = _ref3[1];
+        var defaultDependency = "";
+        var namedDependencies = "";
+        var moduleDependency = "";
+        var dependencyEntries = Object.entries(dependencies);
+
+        // 检查是否有 module 类型的导入（如 import './index.less'）
+        // 通过检查 __module__ 标记或依赖项中的 module 类型
+        var hasModuleType = ((_dependencies$__modul = dependencies["__module__"]) === null || _dependencies$__modul === void 0 ? void 0 : _dependencies$__modul.importType) === "module" || dependencyEntries.some(function (_ref4) {
+          var _ref5 = _slicedToArray(_ref4, 2),
+            importType = _ref5[1].importType;
+          return importType === "module";
+        });
+        if (hasModuleType) {
+          // module 类型：直接生成 import 'packageName'，不再处理其他依赖
+          return pre + "import '".concat(packageName, "';\n");
+        }
+
+        /** 超过三项换行 */
+        // 排除 __module__ 标记
+        var validEntries = dependencyEntries.filter(function (_ref6) {
+          var _ref7 = _slicedToArray(_ref6, 1),
+            key = _ref7[0];
+          return key !== "__module__";
+        });
+        var wrap = validEntries.length > 3;
+        validEntries.forEach(function (_ref8, index) {
+          var _ref9 = _slicedToArray(_ref8, 2),
+            dependencyName = _ref9[0],
+            importType = _ref9[1].importType;
+          if (importType === "default") {
+            defaultDependency = dependencyName;
+          } else if (importType === "named") {
+            if (wrap) {
+              namedDependencies += "".concat(indent).concat(dependencyName, ",\n");
+            } else {
+              namedDependencies += "".concat(index ? ", " : "").concat(dependencyName);
+            }
+          }
+        });
+        if (namedDependencies) {
+          if (wrap) {
+            namedDependencies = "{\n".concat(namedDependencies, "}");
+          } else {
+            namedDependencies = "{ ".concat(namedDependencies, " }");
+          }
+          if (defaultDependency) {
+            defaultDependency += ", ";
+          }
+        }
+        return pre + "import ".concat(defaultDependency).concat(namedDependencies, " from '").concat(packageName, "';\n");
+      }, "");
+    }
+  }]);
+  return ImportManager;
+}();
+
+/** 将第一个字符转大写 */
+export var firstCharToUpperCase = function firstCharToUpperCase(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+
+/** 将第一个字符转小写 */
+export var firstCharToLowerCase = function firstCharToLowerCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+};
+
+/** 缩进 */
+export var indentation = function indentation(level) {
+  return " ".repeat(level);
+};
+
+/** 驼峰转中划线 */
+export var camelToKebab = function camelToKebab(str) {
+  return str.replace(/([A-Z])/g, "-$1").toLowerCase();
+};
+
+/** 中划线转驼峰 */
+export var kebabToCamel = function kebabToCamel(str) {
+  return str.replace(/-([a-z])/g, function (_, char) {
+    return char.toUpperCase();
+  });
+};
+
+/** 转换根节点样式 */
+export var convertRootStyle = function convertRootStyle(style) {
+  var rootStyle = {};
+  Object.entries(style || {}).forEach(function (_ref10) {
+    var _ref11 = _slicedToArray(_ref10, 2),
+      key = _ref11[0],
+      value = _ref11[1];
+    // 忽略一些不需要的属性
+    if (key === "_new" || key === "themesId" || key === "visibility" || key === "styleAry") {
+      return;
+    }
+    if (key === "layout") {
+      if (_typeof(value) === "object" && value !== null) {
+        // 处理 layout 对象，动态转换所有属性
+        var layoutObj = value;
+        Object.entries(layoutObj).forEach(function (_ref12) {
+          var _ref13 = _slicedToArray(_ref12, 2),
+            lKey = _ref13[0],
+            lValue = _ref13[1];
+          if (lKey === "position") {
+            if (lValue === "smart") {
+              rootStyle["position"] = "absolute";
+            } else if (lValue !== "inherit") {
+              rootStyle["position"] = lValue;
+            }
+          } else {
+            // 所有布局属性转为小驼峰（React 行内样式使用 camelCase）
+            var camelLayoutKey = kebabToCamel(lKey);
+            rootStyle[camelLayoutKey] = pxtransform(lValue);
+          }
+        });
+      } else if (value === "flex-row") {
+        rootStyle["display"] = "flex";
+        rootStyle["flexDirection"] = "row";
+      } else if (value === "flex-column") {
+        rootStyle["display"] = "flex";
+        rootStyle["flexDirection"] = "column";
+      } else if (value === "smart") {
+        // 处理 layout: 'smart'
+        rootStyle["position"] = "relative";
+      }
+      return;
+    }
+
+    // 根样式转换，统一转为小驼峰（React 行内样式使用 camelCase）
+    // 如果 key 已经是 kebab-case，转换为 camelCase；如果已经是 camelCase，保持不变
+    var camelKey = key.includes('-') ? kebabToCamel(key) : key;
+    if (typeof value === "string" || typeof value === "number") {
+      rootStyle[camelKey] = pxtransform(value);
+    }
+  });
+  return rootStyle;
+};
+
+/** 转换组件样式为 Taro/React 样式 */
+export var convertComponentStyle = function convertComponentStyle(style) {
+  var resultStyle = {};
+  var rootStyle = convertRootStyle(style);
+  if (style.styleAry) {
+    // 处理样式数组
+    style.styleAry.forEach(function (_ref14) {
+      var css = _ref14.css,
+        selector = _ref14.selector;
+      var transformedCss = {};
+      Object.entries(css).forEach(function (_ref15) {
+        var _ref16 = _slicedToArray(_ref15, 2),
+          cssKey = _ref16[0],
+          cssValue = _ref16[1];
+        if (cssKey === "layout") {
+          if (_typeof(cssValue) === "object" && cssValue !== null) {
+            var layoutObj = cssValue;
+            Object.entries(layoutObj).forEach(function (_ref17) {
+              var _ref18 = _slicedToArray(_ref17, 2),
+                lKey = _ref18[0],
+                lValue = _ref18[1];
+              if (lKey === "position") {
+                if (lValue === "smart") {
+                  transformedCss["position"] = "absolute";
+                } else if (lValue !== "inherit") {
+                  transformedCss["position"] = lValue;
+                }
+              } else {
+                // 布局属性转为小驼峰（React 行内样式使用 camelCase）
+                transformedCss[kebabToCamel(lKey)] = lValue;
+              }
+            });
+          } else if (cssValue === "flex-row") {
+            transformedCss["display"] = "flex";
+            transformedCss["flexDirection"] = "row";
+          } else if (cssValue === "flex-column") {
+            transformedCss["display"] = "flex";
+            transformedCss["flexDirection"] = "column";
+          } else if (cssValue === "smart") {
+            transformedCss["position"] = "relative";
+          }
+        } else {
+          // CSS 属性转为小驼峰（React 行内样式使用 camelCase）
+          // 如果 cssKey 已经是 kebab-case，转换为 camelCase；如果已经是 camelCase，保持不变
+          var camelKey = cssKey.includes('-') ? kebabToCamel(cssKey) : cssKey;
+          transformedCss[camelKey] = pxtransform(cssValue);
+        }
+      });
+      resultStyle[selector] = transformedCss;
+    });
+  }
+  resultStyle["root"] = rootStyle;
+  return resultStyle;
+};
+
+/** 转换 styleAry 为 CSS 字符串 */
+export var convertStyleAryToCss = function convertStyleAryToCss(styleAry, parentSelector) {
+  if (!Array.isArray(styleAry)) return "";
+  var prefix = parentSelector ? ".".concat(parentSelector, " ") : "";
+  return styleAry.map(function (_ref19) {
+    var selector = _ref19.selector,
+      css = _ref19.css;
+    if (!selector || !css) return "";
+
+    // 处理选择器，如果是以 > 开头，处理空格
+    var finalSelector = selector;
+    if (finalSelector.startsWith(">")) {
+      finalSelector = "".concat(prefix).concat(finalSelector);
+    } else {
+      finalSelector = "".concat(prefix).concat(finalSelector);
+    }
+    var transformedCss = {};
+    Object.entries(css).forEach(function (_ref20) {
+      var _ref21 = _slicedToArray(_ref20, 2),
+        key = _ref21[0],
+        value = _ref21[1];
+      if (key === "layout") {
+        if (_typeof(value) === "object" && value !== null) {
+          var layoutObj = value;
+          Object.entries(layoutObj).forEach(function (_ref22) {
+            var _ref23 = _slicedToArray(_ref22, 2),
+              lKey = _ref23[0],
+              lValue = _ref23[1];
+            if (lKey === "position") {
+              if (lValue === "smart") {
+                transformedCss["position"] = "absolute";
+              } else if (lValue !== "inherit") {
+                transformedCss["position"] = lValue;
+              }
+            } else {
+              transformedCss[kebabToCamel(lKey)] = lValue;
+            }
+          });
+        } else if (value === "flex-row") {
+          transformedCss["display"] = "flex";
+          transformedCss["flexDirection"] = "row";
+        } else if (value === "flex-column") {
+          transformedCss["display"] = "flex";
+          transformedCss["flexDirection"] = "column";
+        } else if (value === "smart") {
+          transformedCss["position"] = "relative";
+        }
+      } else {
+        transformedCss[kebabToCamel(key)] = value;
+      }
+    });
+    var cssString = Object.entries(transformedCss).map(function (_ref24) {
+      var _ref25 = _slicedToArray(_ref24, 2),
+        key = _ref25[0],
+        value = _ref25[1];
+      // 使用通用工具转换驼峰为中划线
+      var kebabKey = camelToKebab(key);
+      var formattedValue = typeof value === "number" ? "".concat(value, "px") : value;
+      return "  ".concat(kebabKey, ": ").concat(formattedValue, ";");
+    }).join("\n");
+    return "".concat(finalSelector, " {\n").concat(cssString, "\n}");
+  }).join("\n\n");
+};
+
+/** 生成对象代码 */
+export var genObjectCode = function genObjectCode(object, config) {
+  var initialIndent = config.initialIndent,
+    indentSize = config.indentSize;
+  var keys = Object.keys(object);
+  if (keys.length === 0) return "{}";
+  var result = "{\n";
+  keys.forEach(function (key, idx) {
+    var value = object[key];
+    var formattedValue;
+    if (Array.isArray(value)) {
+      formattedValue = JSON.stringify(value);
+    } else if (value && _typeof(value) === "object") {
+      formattedValue = genObjectCode(value, {
+        initialIndent: initialIndent + indentSize,
+        indentSize: indentSize
+      });
+    } else if (typeof value === "string") {
+      formattedValue = JSON.stringify(value);
+    } else {
+      formattedValue = String(value);
+    }
+    result += indentation(initialIndent + indentSize) + "".concat(JSON.stringify(key), ": ").concat(formattedValue);
+    if (idx < keys.length - 1) result += ",";
+    result += "\n";
+  });
+  result += indentation(initialIndent) + "}";
+  return result;
+};
+
+// 导出 code 目录下的函数
+export { getUiComponentCode } from "./code";
+export { getRootComponentClassName } from "./getComponentClassName";

package/dist/esm/utils/pageConfig/converter.d.ts

@@ -0,0 +1,17 @@
+import type { TabBarItemSource, TaroTabBarConfig } from './types';
+/**
+ * 将 TabBar 数据转换为 Taro 配置格式
+ * @param tabBar TabBar 项数组（来自 toJson.tabbar）
+ * @param pageIdToPath 页面 ID 到路径的映射函数，默认格式为 `pages/${pageId}/index`
+ * @param processIcon 处理图标的函数（可选，用于处理 base64 图片）
+ * @returns Taro TabBar 配置，如果验证失败则返回 null
+ */
+export declare function convertToTaroTabBarConfig(tabBar: TabBarItemSource[] | undefined | null, pageIdToPath?: (pageId: string) => string, processIcon?: (iconPath: string | undefined, index: number, type: 'normal' | 'selected') => string | undefined): TaroTabBarConfig | null;
+/**
+ * 获取入口页面 ID
+ * 如果启用 TabBar，返回第一个 TabBar 项的页面 ID；否则返回 null
+ * @param tabBar TabBar 项数组
+ * @param defaultEntryPageId 默认入口页面 ID（当 TabBar 未启用时使用）
+ * @returns 入口页面 ID
+ */
+export declare function getEntryPageId(tabBar: TabBarItemSource[] | undefined | null, defaultEntryPageId?: string): string | null;

package/dist/esm/utils/pageConfig/converter.js

@@ -0,0 +1,105 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import { validateTabBar } from "./validator";
+
+/**
+ * TabBar 数据转换器
+ * 负责将 toJson.tabbar 格式转换为 Taro 配置格式
+ */
+
+/**
+ * 将单个 TabBar 项转换为 Taro 格式
+ * @param item TabBar 项
+ * @param pageIdToPath 页面 ID 到路径的映射函数
+ * @param index TabBar 项的索引（用于生成文件名）
+ * @param processIcon 处理图标的函数（可选，用于处理 base64 图片）
+ * @returns Taro TabBar 项
+ */
+function convertTabBarItem(item, pageIdToPath) {
+  var index = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  var processIcon = arguments.length > 3 ? arguments[3] : undefined;
+  var pagePath = pageIdToPath(item.scene.id);
+  var text = item.text || item.scene.title || '';
+  var taroItem = {
+    pagePath: pagePath,
+    text: text
+  };
+
+  // 添加图标路径（如果存在）
+  if (item.normalIconPath) {
+    taroItem.iconPath = processIcon ? processIcon(item.normalIconPath, index, 'normal') : item.normalIconPath;
+  }
+  if (item.selectedIconPath) {
+    taroItem.selectedIconPath = processIcon ? processIcon(item.selectedIconPath, index, 'selected') : item.selectedIconPath;
+  }
+  return taroItem;
+}
+
+/**
+ * 从文本样式中提取颜色
+ * @param textStyle 文本样式对象
+ * @returns 颜色值（如果有）
+ */
+function extractColorFromTextStyle(textStyle) {
+  if (!textStyle || _typeof(textStyle) !== 'object') {
+    return undefined;
+  }
+  return textStyle.color || textStyle.colorValue;
+}
+
+/**
+ * 将 TabBar 数据转换为 Taro 配置格式
+ * @param tabBar TabBar 项数组（来自 toJson.tabbar）
+ * @param pageIdToPath 页面 ID 到路径的映射函数，默认格式为 `pages/${pageId}/index`
+ * @param processIcon 处理图标的函数（可选，用于处理 base64 图片）
+ * @returns Taro TabBar 配置，如果验证失败则返回 null
+ */
+export function convertToTaroTabBarConfig(tabBar) {
+  var pageIdToPath = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function (pageId) {
+    return "pages/".concat(pageId, "/index");
+  };
+  var processIcon = arguments.length > 2 ? arguments[2] : undefined;
+  // 验证 TabBar 配置
+  var validation = validateTabBar(tabBar);
+  if (!validation.useTabBar) {
+    return null;
+  }
+
+  // 转换 TabBar 项
+  var list = validation.validItems.map(function (item, index) {
+    return convertTabBarItem(item, pageIdToPath, index, processIcon);
+  });
+
+  // 构建 TabBar 配置
+  var config = {
+    list: list
+  };
+
+  // 从第一个 TabBar 项的样式中提取颜色（如果存在）
+  var firstItem = validation.validItems[0];
+  if (firstItem) {
+    var normalColor = extractColorFromTextStyle(firstItem.normalTextStyle);
+    var selectedColor = extractColorFromTextStyle(firstItem.selectedTextStyle);
+    if (normalColor) {
+      config.color = normalColor;
+    }
+    if (selectedColor) {
+      config.selectedColor = selectedColor;
+    }
+  }
+  return config;
+}
+
+/**
+ * 获取入口页面 ID
+ * 如果启用 TabBar，返回第一个 TabBar 项的页面 ID；否则返回 null
+ * @param tabBar TabBar 项数组
+ * @param defaultEntryPageId 默认入口页面 ID（当 TabBar 未启用时使用）
+ * @returns 入口页面 ID
+ */
+export function getEntryPageId(tabBar, defaultEntryPageId) {
+  var validation = validateTabBar(tabBar);
+  if (validation.useTabBar && validation.validItems.length > 0) {
+    return validation.validItems[0].scene.id;
+  }
+  return defaultEntryPageId || null;
+}

package/dist/esm/utils/pageConfig/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 页面配置工具模块
+ * 提供页面配置、TabBar 配置等相关功能
+ */
+export * from './types';
+export * from './validator';
+export * from './converter';
+export * from './pageConfig';
+export * from './tabBarConfig';
+export * from './saveBase64Image';

package/dist/esm/utils/pageConfig/index.js

@@ -0,0 +1,11 @@
+/**
+ * 页面配置工具模块
+ * 提供页面配置、TabBar 配置等相关功能
+ */
+
+export * from "./types";
+export * from "./validator";
+export * from "./converter";
+export * from "./pageConfig";
+export * from "./tabBarConfig";
+export * from "./saveBase64Image";

package/dist/esm/utils/pageConfig/pageConfig.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 页面配置工具
+ * 负责从 systemPage 组件数据生成 definePageConfig 配置字符串
+ */
+/**
+ * 从 systemPage 组件数据生成 definePageConfig 配置字符串
+ * @param systemPageData systemPage 组件的 model.data
+ * @returns definePageConfig 配置字符串
+ */
+export declare function generatePageConfigContent(systemPageData?: any): string;

package/dist/esm/utils/pageConfig/pageConfig.js

@@ -0,0 +1,60 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+/**
+ * 页面配置工具
+ * 负责从 systemPage 组件数据生成 definePageConfig 配置字符串
+ */
+
+var TARO_NAVIGATION_BAR_PROPERTIES = ['navigationBarBackgroundColor', 'navigationBarTextStyle', 'navigationBarTitleText', 'navigationStyle'];
+var TARO_PAGE_CONFIG_TEMPLATE_PROPERTIES = ['navigationBarBackgroundColor', 'navigationBarTextStyle', 'navigationBarTitleText', 'navigationStyle', 'transparentTitle', 'backgroundColor', 'backgroundTextStyle', 'backgroundColorTop', 'backgroundColorBottom', 'enablePullDownRefresh', 'onReachBottomDistance', 'pageOrientation', 'disableScroll', 'disableSwipeBack', 'enableShareAppMessage', 'enableShareTimeline', 'usingComponents', 'renderer'];
+
+/**
+ * 从 systemPage 组件数据生成 definePageConfig 配置字符串
+ * @param systemPageData systemPage 组件的 model.data
+ * @returns definePageConfig 配置字符串
+ */
+export function generatePageConfigContent(systemPageData) {
+  var pageConfig = {};
+  if (systemPageData) {
+    var useNavigationStyle = systemPageData.useNavigationStyle;
+
+    // 确定要使用的属性列表
+    var propertiesToUse = [];
+    if (useNavigationStyle === 'default') {
+      // 如果 useNavigationStyle 为 default，使用 TARO_NAVIGATION_BAR_PROPERTIES
+      propertiesToUse = TARO_NAVIGATION_BAR_PROPERTIES;
+    } else {
+      // 否则使用 TARO_PAGE_CONFIG_TEMPLATE_PROPERTIES
+      propertiesToUse = TARO_PAGE_CONFIG_TEMPLATE_PROPERTIES;
+    }
+
+    // 从 systemPageData 中提取配置属性
+    propertiesToUse.forEach(function (prop) {
+      if (systemPageData[prop] !== undefined && systemPageData[prop] !== null) {
+        var value = systemPageData[prop];
+        // 处理不同类型的值
+        if (typeof value === 'string') {
+          pageConfig[prop] = "'".concat(value, "'");
+        } else if (typeof value === 'boolean' || typeof value === 'number') {
+          pageConfig[prop] = value;
+        } else if (_typeof(value) === 'object') {
+          pageConfig[prop] = JSON.stringify(value);
+        }
+      }
+    });
+  }
+
+  // 如果没有找到任何配置，设置默认的 navigationBarTitleText
+  if (Object.keys(pageConfig).length === 0) {
+    pageConfig.navigationBarTitleText = "'\u9875\u9762'";
+  }
+
+  // 生成配置字符串
+  var configLines = Object.entries(pageConfig).map(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      key = _ref2[0],
+      value = _ref2[1];
+    return "  ".concat(key, ": ").concat(value);
+  });
+  return "export default definePageConfig({\n".concat(configLines.join(',\n'), "\n})");
+}

package/dist/esm/utils/pageConfig/saveBase64Image.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Base64 图片处理工具
+ * 负责将 base64 图片保存为本地文件
+ */
+import type { ImageFileInfo } from './types';
+/**
+ * 处理 TabBar 图标，如果是 base64 则准备保存为文件
+ * @param iconPath 图标路径（可能是 base64 或普通路径）
+ * @param tabBarIndex TabBar 项的索引
+ * @param type 图标类型（'normal' 或 'selected'）
+ * @param imageFiles 用于收集需要保存的图片文件的数组（可选）
+ * @returns 处理后的图标路径（用于 app.config.ts），如果不是 base64 则返回原路径
+ */
+export declare function processTabBarIcon(iconPath: string | undefined, tabBarIndex: number, type: 'normal' | 'selected', imageFiles?: ImageFileInfo[]): string | undefined;

package/dist/esm/utils/pageConfig/saveBase64Image.js

@@ -0,0 +1,105 @@
+/**
+ * Base64 图片处理工具
+ * 负责将 base64 图片保存为本地文件
+ */
+
+/**
+ * MIME 类型到文件扩展名的映射
+ */
+var MIME_TO_EXT = {
+  png: 'png',
+  jpg: 'jpg',
+  jpeg: 'jpg',
+  gif: 'gif',
+  webp: 'webp',
+  svg: 'svg'
+};
+
+/**
+ * Base64 图片解析结果
+ */
+
+/**
+ * 从 base64 字符串中提取图片格式和 base64 数据
+ * @param base64Str base64 字符串
+ * @returns 解析结果或 null
+ */
+function parseBase64Image(base64Str) {
+  if (typeof base64Str !== 'string' || !base64Str.startsWith('data:image/')) {
+    return null;
+  }
+  var match = base64Str.match(/^data:image\/([^;]+);base64,(.+)$/);
+  if (!match) {
+    return null;
+  }
+  return {
+    mimeType: match[1],
+    base64Data: match[2]
+  };
+}
+
+/**
+ * 根据 MIME 类型获取文件扩展名
+ * @param mimeType MIME 类型
+ * @returns 文件扩展名，默认为 'png'
+ */
+function getFileExtension(mimeType) {
+  return MIME_TO_EXT[mimeType.toLowerCase()] || 'png';
+}
+
+/**
+ * 生成唯一的文件名
+ * @param index TabBar 项的索引
+ * @param type 图标类型
+ * @param extension 文件扩展名
+ * @returns 文件名
+ */
+function generateFileName(index, type, extension) {
+  return "tabbar_".concat(index, "_").concat(type, ".").concat(extension);
+}
+
+/**
+ * 处理 TabBar 图标，如果是 base64 则准备保存为文件
+ * @param iconPath 图标路径（可能是 base64 或普通路径）
+ * @param tabBarIndex TabBar 项的索引
+ * @param type 图标类型（'normal' 或 'selected'）
+ * @param imageFiles 用于收集需要保存的图片文件的数组（可选）
+ * @returns 处理后的图标路径（用于 app.config.ts），如果不是 base64 则返回原路径
+ */
+export function processTabBarIcon(iconPath, tabBarIndex, type, imageFiles) {
+  if (!iconPath) {
+    return undefined;
+  }
+
+  // 解析 base64 图片
+  var parsed = parseBase64Image(iconPath);
+  if (!parsed) {
+    // 不是 base64 格式，直接返回原路径
+    return iconPath;
+  }
+
+  // 生成文件名和路径
+  var extension = getFileExtension(parsed.mimeType);
+  var fileName = generateFileName(tabBarIndex, type, extension);
+  var fileSystemPath = "src/assets/tabbar/".concat(fileName);
+  var configPath = "assets/tabbar/".concat(fileName);
+
+  // 如果需要收集图片文件
+  if (imageFiles) {
+    try {
+      // 将 base64 数据转换为 Buffer
+      var imageBuffer = Buffer.from(parsed.base64Data, 'base64');
+      imageFiles.push({
+        filePath: fileSystemPath,
+        fileContent: imageBuffer
+      });
+    } catch (error) {
+      console.error("\u5904\u7406 TabBar \u56FE\u6807\u5931\u8D25: ".concat(error));
+      // 转换失败时返回原路径
+      return iconPath;
+    }
+  }
+
+  // 返回配置路径（用于 app.config.ts）
+  return configPath;
+}